When one is joyful
Uplifting the dog, ensue
The despondency
When one is joyful
Uplifting the dog, ensue
The despondency
Shows when player was taken down based on above Written Account. Based on four 4-player teams for 16 total.
| A | B | C | D | |
|---|---|---|---|---|
| 1 | _ | 1 | 6 | 9 |
| 2 | 11 | 2 | 7 | 10 |
| 3 | 11 | 3 | 8 | 13 |
| 4 | x | 3 | 14 | 16 |
Shows who took down who. Based on four 4-player teams for 16 total.
| A | B | C | D | |
|---|---|---|---|---|
| 1 | Ant | A1 | A1+A2 | A2 |
| 2 | Will | A1 | A2 | A2 or A3? |
| 3 | Mo | A2 | A3 | A1 |
| 4 | x | A3 | A1 | A1 |
For a few months to a year I’ve noticed my Macbook Pro 2013 (13 inch), I’ll be using “MBP” from now on for convenience, not sitting right when in use. It turns out the lithium ion battery was enlarging over time due to use or some fault. I stopped using it for awhile because of it and instead handled some of my other computers instead.
This Winter I finally bit the bullet and decided to order a new battery kit plus back screws from iFixit. I used their products before for this other MBP 2010 (13 inch) that I had whose battery just wasn’t holding charge anymore. The huge difference between the batteries of both computers made me push off this task until now.
On the MBP 2010, you simply had to unscrew the backplate and you would have access to the hard drive, battery, and RAM chips, making it very easy to DIY your repairs. No adhesives involved or soldering.
In contrast the MBP 2013 has the battery glued on and the repairer has to unhook or remove a few components to even get to it. In iFixit’s rating, the MBP 2010 batter repair score is a “Easy” while the MBP 2013 is a “Hard” and I totally agree. That being said, I’ve thankfully repaired a few things in my day already it didn’t turn out to be too bad.
I also had this magnetized white board from iFixit (I know, I think I’m obsessed) to hold the screws and also write notes on. You can see how it didn’t end up being too many layers of screws to get through.
The hardest part was using the adhesive remover on the battery in order to melt out the glue. For each cell, I had to use a few drops and wait 2-3 minutes for it to take effect. I also had to prop the laptop up a at times in an incline so that the remover slides under the battery. I managed to do it without damaging anything like the track pad or keyboard. I also put in a bit more work to get rid of the leftover glue strips.
I wore an n95 mask throughout the process in case the battery exploded while in the spare bedroom with a window open and fan ready. I actually read more on how to handle lithium ion batteries and it’s best to have a bucket of sand or at least water nearby, and be outside. Since it was around 10 degrees out, I opted to be inside. In hindsight I should have probably sent it to a certified shop and let them handle it to be safe.
I’m happy I finished it with no incidents and I dropped off the old battery at a nearby Best Buy since they can handle e-waste. Apple really needs to curb their efforts in making their products anti-repairer. If I buy another Apple computer in the future I’d opt in for a Mac Mini since it has no battery. But for now, I can at least rely on this repaired laptop for any iOS/macOS related development.
Happy Holidays and be safe.
]]>First, let’s go over the common number system we use in our day-to-day lives: the base-10 system.
Let’s study the number 1023 considering we’ll be counting to it later. The base this number is based on is 10 and we can break it down further to make this more apparent. Let’s replace all the digits in the number like so: abcd and break down what this number actually means.
1023
----
abcd
a: 10^3 = 1000 * 1
b: 10^2 = 100 * 0
c: 10^1 = 10 * 2
d: 10^0 = 1 * 3
--------------------
a + b + c + d = 1023
The 10 that you see in the lefthand side after the colon is our current base. We figure out what that place stands for by the positioning it has and use that numbered place as a exponent, then we multiply by the number that is there. Note that for a given digit, a number from 0-9 can be used and that’s it. We then add all the products up and get the number it stands for. This might seem unproductive but the teardown should serve as a reminder of how the common decimal system works and will help as a scaffold to learning binary and any other base number system!
Now, let’s look at a binary representation of 1023:
0b1111111111
The “0b” stands as a preamble to tell the reader the number they’re about to read is a binary number (Side note: “0d” is what you can use to show a base-10 number). It’s optional for the most part but helps to be explicit to the reader otherwise they may read the 1’s as a base-10 number. Another way to represent the binary number is to break it into groups of 4 digits and pad the left with 0’s, this makes it easier for a human reader to calculate it. I’ve added letters at the bottom to help calculate as well.
0011 1111 1111
---- ---- ----
abcd efgh ijkl
a: 2^11 = 2048 * 0 = 0
b: 2^10 = 1024 * 0 = 0
c: 2^9 = 512 * 1 = 512
d: 2^8 = 256 * 1 = 256
e: 2^7 = 128 * 1 = 128
f: 2^6 = 64 * 1 = 64
g: 2^5 = 32 * 1 = 32
h: 2^4 = 16 * 1 = 16
i: 2^3 = 8 * 1 = 8
j: 2^2 = 4 * 1 = 4
k: 2^1 = 2 * 1 = 2
l: 2^0 = 1 * 1 = 1
------------------
a + b + ... + k + l = 1023
We simply replaced the “10” base with “2” instead. You can see that a certain digit can only be either a 1 or a 0 now instead of 0-9. The digit can also be used as a switch that decides whether we add the given weight or not (0 = don’t add, 1 = add)
We then sum up all the weights and get our number: 1023 By the way, a shortcut to calculating this: Since we have all the 1’s in a row we can look at the first 0 before the left-most 1, determine it’s weight (b is 1024 in this case) and simply subtract 1 from it to get the overall value. Likewise, adding 1 to the binary 1023 will make all the current 1 digits switch to 0 and then switch b’s place to a 1 to represent 1024.
Now, let’s apply what we learned to counting by hand. In base-10, we tend to use each finger (or digit if you will) on our hand to have a weight of 1 only, which is inefficent since we can only count from 0-10. We tend to keep track of where we’re at in our head and recycle use of our fingers to continue adding by 1. I’m sure there are other more efficient finger counting processes but I won’t go over them.
Hold your hands palms up towards you. Let’s map each finger to a digit in binary:
0011 1111 1111
---- ---- ----
abcd efgh ijkl
a: 2^11 = 2048 (no finger here)
b: 2^10 = 1024 (no finger here)
c: 2^9 = 512 (left hand thumb)
d: 2^8 = 256 (left hand index)
e: 2^7 = 128 (left hand middle)
f: 2^6 = 64 (left hand ring)
g: 2^5 = 32 (left hand pinky)
h: 2^4 = 16 (right hand pinky)
i: 2^3 = 8 (right hand ring)
j: 2^2 = 4 (right hand middle)
k: 2^1 = 2 (right hand index)
l: 2^0 = 1 (right hand thumb)
Now I’ll show you how progression of counting with your fingers work. You simply count up from the right to left. When you see a 1, you hold that finger up to represent that it’s “on”. A finger that’s down is “off” and is a 0. I’ll show the base-10 value as well via 0d delimiter to assist.
00 0000 0000 = 0d0
-- ---- ----
cd efgh ijkl
00 0000 0001 = 0d1
-- ---- ----
cd efgh ijkl
00 0000 0010 = 0d2
-- ---- ----
cd efgh ijkl
00 0000 0011 = 0d3
-- ---- ----
cd efgh ijkl
00 0000 0100 = 0d4
-- ---- ----
cd efgh ijkl
.
.
.
(let's jump to 0d16 which is your left hand pinky)
00 0001 0000 = 0d16
-- ---- ----
cd efgh ijkl
00 0001 0001 = 0d17
-- ---- ----
cd efgh ijkl
00 0001 0010 = 0d18
-- ---- ----
cd efgh ijkl
.
.
.
(finally jump to 0d1020 which is everything but right thumb and index)
11 1111 1100 = 0d1020
-- ---- ----
cd efgh ijkl
11 1111 1101 = 0d1021
-- ---- ----
cd efgh ijkl
11 1111 1110 = 0d1022
-- ---- ----
cd efgh ijkl
11 1111 1111 = 0d1023
-- ---- ----
cd efgh ijkl
c: 2^9 = 512 (left hand thumb)
d: 2^8 = 256 (left hand index)
e: 2^7 = 128 (left hand middle)
f: 2^6 = 64 (left hand ring)
g: 2^5 = 32 (left hand pinky)
h: 2^4 = 16 (right hand pinky)
i: 2^3 = 8 (right hand ring)
j: 2^2 = 4 (right hand middle)
k: 2^1 = 2 (right hand index)
l: 2^0 = 1 (right hand thumb)
What’s nice about this system of counting is you don’t have to cache any number in your head. As long as you don’t move your fingers they can serve as a snapshot to where you’re at in your counting.
To figure out the max value you can count to with a given number of binary digits, use this simple formula:
(a^n)-1
Where a is 2 for the binary system and n is the number of binary digits you can work with. So, since a typical human has 10 fingers the formula yields: (2^10)-1 = (1024)-1 = 1023
For decimal, a is 10 and n is however many digits you’re working with.
You can create a base system with any number. Another popular one for programmers is hexadecimal, delimited with “0x”. The base for it is 16 It’s useful for programmers because one hexadecimal digit can hold four binary digit’s worth of value. It does this by counting not just from 0-9 but adds abcdef as values as well where a represents 10, and f is 15. Here are some example hexadecimal values where we show the hex representation, binary, then decimal.
0xbc
0b1011 1100
0d188 = (128 + 0 + 32 + 16) + (8 + 4 + 0 + 0)
-----------
0x9f
0b1001 1111
0d159 = (128 + 0 + 0 + 16) + (8 + 4 + 2 + 1)
For the decimal representation, I broke down each binary digit’s value to show how I came up with the calculation. Also, you can see how each digit in hexadecimal maps to a cluster of 4 binary digits (for 0xbc, b = 0b1011 and c = 0b1100)
Another fun tid bit: In binary, if the first digit (right most) is a 1 then it’s odd! Otherwise a 0 denotes an even number. How convenient :D
Congrats, now you can count like a computer. Happy counting!
]]>Who can be reaching out to you so early? Is it one of your group texts? Is it work? You pick up the phone and start the morning routine.
You see a myriad of text and email notifications about various accounts. All related, whether you notice at the moment or not, to two common things. An email and a password. The dreaded day has come.
dangCoolPass44! dangCoolPass45! dangCoolPass50!
Are these familiar? Maybe similar to a password used at work where they require a biweekly or monthly update of passwords but laziness kicks in after the first 3 months and a workaround is found by incrementing a digit.
We tend to reuse passwords because we can only devote so much time and bandwidth to the chore of remembering them. We may just break down, rotate between four or five passwords at a time, and hope for the best. It’s natural to consolidate laborious tasks to make our lives easier.
What if I told you there’s a better way to manage your passwords that doesn’t require remembering them all? Stick with me, we’ll get through this.
Every service in today’s Internet connected world is (usually) based around two things: an email and a password. It’s a typical method because most Internet users have or can create the pair, it’s simple to implement an account recovery flow, password resets, etc. But it has at least one con: it places the burden of managing passwords on the user.
There are other ways for services to handle accounts but most require action and knowledge of the end user to pick up. There’s a constant tug-o-war between ease of use and security. So, for now, we’re stuck with passwords and I dream of the day when we no longer depend on them.
Here’s an example of an average user’s password collection where P[n] is a password and A[n] is an account:
P1
/ | \ \
A1 A2 A3 A4
------------------
P2
/ | \ \
A5 A6 A7 A8
This is a one-to-many relationship between a given password and associated accounts. When a password gets compromised (or “hacked”), you end up in a situation like so, where an “x” delimits a need to reset the password.
P1
/ | \ \
A1 A2 A3 A4
------------------
P2
/ | \ \
x x x x
A5 A6 A7 A8
This person now has to reset passwords for accounts A5 through A8.
An ideal setup is as follows, where each password is only tied to one account, a one-to-one relationship:
P1 P2 P3 P4 P5 P6
| | | | | | ...
| | | | x |
A1 A2 A3 A4 A5 A6
As you can see, only when P5 was compromised, the owner just had to reset the A5 account. But, dang, that’s a ton of passwords to remember!
The easiest situation, but least secure, is to use one password for all accounts:
P1
/ / / | \ \ ...
A1 A2 A3 A4 A5 A6
The great thing is that you CAN have this setup while also having it be secure! It’ll look something like this:
PM
/ / | | \ \
P1 P2 P3 P4 P5 P6
| | | | | | ...
| | | | | |
A1 A2 A3 A4 A5 A6
The PM here is a Password Manager and I’m about to preach it up.
A password manager is specialized software for handling one thing: Passwords. And it does it extremely well.
It can store passwords, generate new ones, remember the history of any changes for a given account, store notes, URLs, and more. This data is stored in a secure fashion so only you can access it. They tend to have clients that work on smart phones, desktops, and at the least web browsers .All you have to do is remember one password to access the password manager.
Now, it sounds like this is an “all eggs in one basket” situation and you’d have a worse situation if your password manager account got compromised. I have one answer to that though I won’t go into detail in this blog post: Two Factor Authentication (2FA). Enable it on whichever password manager you pick and use it! I also highly encourage you to enable it on any account you deem is important (email, banks, etc.) As for the one password you use, I recommend the multi-word approach as it tends to be more secure and easier to remember. Just don’t forget to setup that 2FA!
Next, I’m only going to go over two accounts, both of which reside in different types of implementations. The two types are cloud based service and the other a local database.
A Cloud based service is the most common and has the highest ease of use. A company or some entity manages the service and often make money by having businesses pay them for support and/or sharing of passwords within them. A service often has a free tier that individuals can use with a restriction of not being able to share passwords with other users.
The “cloud” comes in with the server based storage and syncing of your passwords between all your devices. When you connect to the service through a client application it’ll fetch the cloud-based (let’s call it “remote”) copy of your passwords and determine whether your local or remote is the latest. The service usually has an automatic and/or manual way to deal with conflicts, but if you’re the only one accessing the password store you shouldn’t see this often.
Signing up tends to be as simple as any other service: you just need an email and a password. Remember, this pair of credentials is the key to all the others in the long run, so keep it secure but accessible. And enable 2FA!
These services commonly have a web-based client to connect to and reliable while you have an Internet connection. There are also native clients applications that live on smart phones and desktops. I highly recommend downloading these native clients on personal devices and logging in as they act as local copies even when your Internet connection goes down.
My current preference to this type is Bitwarden as it’s a great mash up of open source, ease to use, and a company devoted to transparency and trust. In actuality, Bitwarden is a mix of the two types we go over in this post (cloud + local database) since you can still access local copies of your passwords when off-line, but it’s easier to consume it as cloud based. I primarily use it for my work accounts since I prefer a more hands on approach to personal passwords, which we’ll go into next.
A local database type of password manager relies on a pair of things: An encrypted database file and an application that can read, write, decrypt, and encrypt it at will of the owner. There’s not usually an Internet or company dependency here besides fetching the applications to access the database file. It instead relies on volunteers of open source code contributors to maintain the applications and is created with decades-hardened of cryptography technology. There are solutions that are maintained by a company as well if that’s desired.
Once you have the application, you can create a database file and start loading/generating passwords into it. The database file is usually locked via a password but based on the application you can use biometrics, a USB dongle, whatever is supported! You can also enable 2FA on it and while I suggest it here as well, because you will be maintaining the file you can just make sure 2FA is on whatever syncing process you’ll be utilizing.
Side note: When downloading these native applications, it’s important to consider their integrity via methods like SHA-1 hashing which I won’t go into here. But feel free to hit me up about it or wait for a possible blog post.
This type, however, ultimately relies on the user to maintain their database file. Think of this as a manual transmission car compared to an automatic. Instead of having a service back up and store the passwords for you, you’ll have to take it upon yourself to do it.
Some easy ways to backup this file is to utilize a service you’re already using, such as Google Drive, Dropbox, or NextCloud. Just remember to have 2FA enabled on the service you use as that’s the point of access to your password database.
My personal choice for Local Database PMs is KeepassXC for desktop (Windows/MacOS/Linux) and Keepass2Android for my Android phone. There are iOS equivalents but I’m not familiar with any at the moment. You can search for “keepass” and do some research to find one. These are based on the original application called KeePass Password Safe which was only made for Windows.
I’m going to end this post with suggestions on adapting to using a password manager. Some people like to get everything done at once but it’s important to realize that you may have countless of accounts and this could take awhile to get done with! Instead, I suggest a method of transitioning as you access your accounts. I also suggest starting with less important accounts so that you get used to the new process and if something goes wrong it’ll be less nerve wrecking to fix. Remember that most accounts have a way to recover them so don’t be afraid. Newly created accounts are also a good target.
The next time you access your bank account update your password to use a generated and stored one from your password manager (and enable 2FA if not already!) Amazon shopping? Update the password. Eventually, you’ll have encompassed most of the accounts that matter and sooner or later after that you’ll build it into your routine for everything.
Happy password managing!
]]>I have a fond memory of Grant coming to U of I’s Engineering Open House back in 2009. I didn’t get to secure a ticket to see him but I do remember a crowd gathering around him outside sometime. I believe a friend at the time was a head organizer for the events and he was ecstatic to secure Grant as a participant.
As a tribute, I decided to finally break open a pHAT I bought for Raspberry Pis and upgrade the one I’ve been utilizing. A pHAT is a hardware component add-on and stands for (pi?) Hardware Attached on Top. It usually requires no soldering to attach to the Raspberry Pi and is thus easily removable/installable. This one, however, does require soldering to put together at first.
Here’s my setup:
After I (poorly) soldered on the LED matrices, I taped on the 40-pin connector to start soldering that on. Thanks Pimoroni for the tip!
Once finished, I attached it to the Pi and eagerly assembled the case back on.
I booted up the pi, followed the tutorial for how to program the pHAT, and got LEDs to turn on! Oops, one of the rows of pixels wasn’t on, though. See the 6th matrix of LEDs, 3rd row from the bottom.
I probably should have tested it first before assembling the case back on!
I hit up Pimoroni’s Discord channel and posted my issue. Someone got back to me and gave feedback on my soldering job on the afflicted matrix, saying the joins probably weren’t complete. Again, I haven’t soldered in awhile so my skills were rusty.
I opened up the case again, took off the pHAT, fired up my soldering iron once again, and redid the joins on the matrix that had the issue.
I tested it to make sure the once-broken pixels turned on, and they did! I assembled everything back togather and now have a sweet attachment to the Pi that’s on my desk.
Thank you for the inspiration and hard work, Grant. We’ll all miss you.
There are various intersections in my hobbies of reading literature and watching films and this was certainly one of them. What made this occurrence different was how I was coming out of a fever dream of watching the Criterion compilation of Dekalog films lent to me by a good friend and was craving more. Around this time I had received a newsletter email from Criterion about new films they were showing through their Channel service. One film caught my eye: The Last Picture Show.
The image that caught my attention was of a young Jeff Bridges, an actor I’ve only known from his modern renaissance of movies like The Big Lebowski and Tron: Legacy.
I read more about the film only to learn it was based on the third novel of author Larry McMurtry’s Thalia Trilogy. The trio of books center around a small town called Thalia which happens to be a real town though McMurtry’s writing is more inspired by his personal experience in Archer City, Texas.
The first two books, Horseman, Pass By and Leaving Cheyenne, heavily involve cowboy main characters whose jobs center around farms in the region of Thalia, making me realize these may have been the first books I’ve read with that backdrop, and were intriguing considering my suburban upbringing. The third book, in which this blog post partly has a namesake of, turns out to be more familiar including senior high schoolers dealing with adult issues while their small town is figuratively falling apart around them.
While I’ve finished the novel I have yet to watch the movie for The Last Picture Show, and Criterion’s showing seemed to have been temporary. I’ll have to track it down one of these days to finally see it.
I highly recommend the trilogy to anyone and am grateful to McMurtry for these fantastic novels. I’ll be queuing more of his work for future reading!
]]>
For (N) tomatoes you have, you’ll want about (N - 1) habanero peppers.
After eating some great homemade habanero salsa in Father’s Day weekend I made a goal of the incoming week to learn how to make this. My mom indulged me on the complicated recipe and I fell in love with it after putting it on wraps, eating it with tortilla chips, etc.
This should be a great base to work off of if you want to add some variation due to it’s simplicity. Habanero salsa in blender with wrap. And dog on bottom left.
Enjoy!
]]>Cryptography is all around us in the Internet. The process of fetching this blog page uses the HTTPS protocol which incorporates Transport Layer Security (TLS, formerly SSL), whose algorithm includes key exchanges between your browser and the server this blog is hosted on.
We’ll be going over Keys.pub, software that is striving to make the creation and usability of cryptographic keys as user friendly as possible. It borrows many ideas and technologies from Keybase.io, which is a small company that was recently bought by the video conferencing software company, Zoom, in order to improve its cryptography implementations.
Due to the uncertain future of Keybase.io, I ran across the Keys.pub project and believe it’ll one day be a worthy successor to Keybase.io
Let’s say Barret wants to send a message, [m], to Tifa.
(B)arret [m]
|
|
|
(T)ifa
The problem is that Barret wants to send it without anyone else reading it since it’s a secret. Barret and Tifa both decide to try out the application Keys.pub They install the software on their computers. The first thing it asks Barret is to create a password. This password is to unlock the Keys.pub application and access his keychain.
The keychain is what will hold Barret’s public/private key(s), which he’ll generate next, as well as other functionality within the Keys.pub app. He’ll have to type this in for every new session.
After creating the password (or by clicking “New” in keys sub-menu), the app will prompt to generate a key. Since Barret would like to sign and encrypt messages/payloads, he sticks with the default choice and clicks “Generate”.
Barret gets a confirmation screen with his public key displaying on it. It’s also added in the “keys” sub-menu and is bold to show he has the private key.
The app gives him the choice to publish/link the key. This is one of the main features of Keys.pub, which allows others to search for your key via Keys.pub or through one of the supported sites. Associating your public key to these sites/services serves as proof that you’re in control of them. For example, you can see mine here for my website.
For now, Barret chooses to skip this by pressing “later”.
He clicks on his new public key within the “keys” sub-menu and notes down the public key, kex1amzy67az40ymunr8aguguz5209ujmhaqc4dacmezw8lf4tkcmz3srhnprf, to give to Tifa later.
Both Tifa and Barret are good to exchange keys.
(B) [m]
b_priv_k (****)
b_pub_k (kex1a...)
|
|
|
(T)
t_priv_k (****)
t_pub_k (kex13...)
They exchange their public keys remotely or in-person to ensure integrity of the keys. Their private keys should never be shared with anyone.
(B) [m]
b_priv_k (****)
b_pub_k (kex1a...)
t_pub_k (kex13...)
|
|
|
(T)
t_priv_k (****)
t_pub_k (kex13...)
b_pub_k (kex1a...)
Both Barret and Tifa add the public keys manually to their Keys.pub client applications. Note that they could have also fetched it from other avenues if they published them, such as my website example.
Going back to Barret and Tifa’s situation: Barret goes to the Tools->Encrypt option, selects Tifa’s public key address as the “To” field, selects his key in the “Signed by” so that she knows it’s him (otherwise it’s anonymous), plugs in the message [m] as the payload, and the app automatically encrypts it as he types. If a file was chosen, the encrypted file would output in the same directory as the original.
Barret sends this encrypted message [em] over to Tifa through any remote channel considering it’s encrypted and should be safe from tampering.
(B) [m] -> [em]
b_priv_k (****)
b_pub_k (kex1a...)
t_pub_k (kex13...)
|
|
|
(T) [em]
t_priv_k (****)
t_pub_k (kex13...)
b_pub_k (kex1a...)
Tifa then types in the message from her Keys.pub application within the “Decrypt” sub-menu option, and she sees the plaintext message along with verification that her friend Barret sent it.
After all this, it may seem like a hassle to send simple encrypted messages between friends. Why not just use applications that state they do this in the first place?
The answer has to do with trust. How much do you trust the applications you use? Has it been audited by a third party company to validate it’s claims? Is the code open and available for it? Can you be assured 100% that the installed app you have on your phone or computer hasn’t been tampered with?
Using applications like Keys.pub can help get rid of the middle-man dependency on the cryptography, or at the least add an additional layer of encryption to your sent messages/files. This may not be worth the effort to go through, but imagine being in the shoes of a whistle blower or sending payloads that include sensitive data like bank routing or social security numbers.
Just think of it as a tool and know you have the option of using it if needed. Or just treat it like a toy technology to get a basic understanding of how a modern day marvel (key-exchange cryptography) works!
Keys.pub seems like it’s improving as time goes on, and it has some neat tricks up its sleeve, such as a wormhole tunnel to move files between computers. If you have questions about any of them feel free to shoot me a message and I’d be happy to walk through it with you.
]]>Stay safe out there.
]]>