Posts on Robby Zambito

Languages that do not use prefix notation are weird

Fri, 23 Jun 2023 00:35:43 -0400

I don’t mean that you should avoid such languages, but rather that they are exceedingly uncommon.

For some reason, prefix notation is often associated with Lisp. In reality, there are very few languages that do not use prefix notation. Off the top of my head, I can only think of Forth, and Postscript. Consider the following:

foo(a, b)

What language is this? Well, it could be C, C++, Java, Javascript, Python, C#…

Great. That looks like a normal procedure call. It could be one of many languages, assuming this is not a complete statement (as it would be missing a semicolon in some languages). Now, what if we remove the useless comma:

foo(a b)

And let’s get a little crazy, and move the opening parenthesis to the begining of the expression:

(foo a b)

What language do we have now? Well, it could be Common Lisp, Clojure, Elisp, Scheme… Generally, it is some dialect of Lisp.

How did we move the operator in relation to the operands? We moved it nowhere.

The only reason that prefix notation is associated with Lisp, is because most other languages have a few inconsistencies. Namely, arithmetic operators like +, -, *, and /. These operators are usually treated in a special way, and given an infix syntax; they are placed between its operands: a + b. In most programming domains, the vast majority of operations are procedure calls - not arithmetic operations. The importance of these operators are blown out of proportion because of how familiar they are. In practice using a function-like notation for them is not a big deal.

The operator is always placed before any operands in Lisp. It does not represent any operators in a special and inconsistent way. Expressions like (+ a b) may look strange at first, but just consider: + is simply the chosen name for the add procedure. If we use the name add instead, we get:

(add a b)

And if we apply the inverse of the previous transformation, we get:

add(a, b)

Which is really not all that strange :)

Using Lisp for Game AI

Sat, 22 Jan 2022 14:25:47 -0500

The relationship I have had with Lisp until recently has basically amounted to: “It sounds interesting, it seems highly polarizing, and I have no immediate reason to learn it”.

It sounded interesting to me because I have heard people describe it as both being very simple, and having features that other languages lack. People seem to have very strong opinions, both for and against the use of Lisp. Some express a nearly religious fascination with Lisp, while others express a hatred toward the syntax which is very unfamiliar to those coming from other programming languages.

Last year I started using the GNU Guix package manager and operating system, which has given me a reason to start giving Lisp a serious try. Guix uses the GNU Guile implementation of Scheme, which has an interesting ability to be embedded in C programs, similar to Lua.

When I was in college I took an AI class, where one of my projects was to implement a game, and make an AI that would play the game. The game I chose to implement was Othello, which my family has played a lot with each other. At the time, my go-to programming language was Scala, so that’s what I used to create the project. This project wasn’t particularly flexible; to change which AI was used, the user had to modify the code and recompile the game. You can see in the main function, I had some pre-defined configurations commented out so I could easily uncomment what I wanted to use.

Since I’m familiar with C, I decided an interesting way to expand my knowledge of Lisp would be to recreate this project using C for the game logic, and using Scheme for the AI. I have created this project, it can be found here.

If you wish to give it a try, you can clone the project using:

git clone https://git.robbyzambito.me/robby/othello-ai-guile-c.git

You can see the dependencies required for building in the manifest.scm file. If you have the Guix package manager installed on your system (it can be installed on any GNU/Linux distro) you can simply use the guix shell command to spawn a shell with the required dependencies. When you have a shell with the dependencies, simply run make to build. You can find the output under the newly created ./bin folder.

The game works by specifying a script to use for each player as command line arguments. If no script is specified for a certain player, the game will prompt for a move from standard input. Some example scripts can be found under the strategies directory.

I encourage you to try writing your own scripts! If you write a script that you’d like to share, feel free to either email me a patch, or get in touch with me however works best and I will add it to the repository.

My next desire is to create an AI for the game Rocket League which is implemented in Lisp. There is a community of people who create bots for Rocket League, and run tournaments which they compete their bots against each other. I think it would be particularly fun to try to make a bot which tries to adapt to the opponents behaviour. Given how easy it is to dynamically generate and evaluate code using Lisp, I think it would be interesting to try making the bot adapt to the opponent by continuously building a knowledge bank about the opponents behaviour, and using that knowledge to create or modify strategies to more conistently outplay the opponent.

How to Set Primary X Display on Sway

Mon, 23 Aug 2021 20:56:40 -0400

In my PC setup, I have three displays. My somewhat recent post about my setup is outdated now; from left to right I have a 1440x900 60Hz monitor oriented vertically, a 1920x1080 120Hz monitor, and a 1920x1080 60Hz monitor.

I noticed some games would try to run at the resolution and refresh rate of my leftmost vertical monitor, which is not what I want. There is no way to set a “primary display” in Sway, because that construct doesn’t exist in Wayland. Applications simply open on the display you have focused.

However, many applications (particularly games) will try to query for the primary display. XWayland will (in my experience) default to setting the primary display to the one which is the closest to the “origin” (top left pixel). This can be remedied by running xrandr --listmonitors to find what X thinks the names of your displays are, and then using xrandr --output XWAYLANDN --primary where N is the number of the correct display, to set the primary display.

I wrote a basic script to handle this:

#!/bin/sh

display=$(xrandr --listactivemonitors | grep "$1" | head -n1 | cut -d' ' -f6)

if [ -n "$display" ]; then
    xrandr --output $display --primary
fi

I have this saved in ~/.local/bin/set-correct-monitor so I can use it anywhere. What this does is grep the output of xrandr --listactivemonitors for the script argument, and set the display to the first display that matches. For example, I run set-correct-monitor 300+900 to set my display, since that is the position of the monitor I want to be considered my primary.

Doing this will work until you do one of several things:

logout
otherwise kill Sway
disconnect a monitor

The first two were pretty okay for me to deal with for some time, since usually I only logout once a day, and many games don’t run into an issue with this, particularly if they are run in “windowed mode” (which I recommend). The last was pretty frustrating for me though, because I use a KVM switch to change between my work laptop and my PC. Every time I switch between devices, my primary display usually defaults back to my vertical monitor.

To make this setting persist, I made a small C program which will execute a command each time a new display is attached. The program can be found here: https://git.robbyzambito.me/robby/wayland-run-on-new-display.git

By adding this line to my ~/.config/sway/config, my primary display is always properly set when I run Sway:

exec wayland-run-on-new-display set-correct-monitor 300+900

Tips and Tricks for Taking Screenshots and Selecting Text From Images on Sway

Wed, 28 Jul 2021 18:02:31 -0400

Several days ago I saw someone rant about how there were no good programs for copy text from an image. They were using the command line tool tesseract, but they felt it was too clunky for them. They were using tesseract by taking a screenshot of the text they were trying to copy, saving the screenshot to a file, and running tesseract on that file to generate a new file with the text that was found. After all that, they would open the final text file, copy the text, and delete the file.

This is something that I actually used to do a lot with my Android phone, before they decided to remove the feature for some reason (or at least move it somewhere that I haven’t been able to find for years) so I decided to see how easy it would be to hook up grim and slurp with tesseract to copy text from images the same way.

It turns out, it was not that hard to do:

grim -g "$(slurp)" - | tesseract - - | wl-copy

This works by selecting the region using "$(slurp)", and using grim -g to take a screenshot of that region. The file is then “saved” to standard output (that’s what the - represents here). tesseract is then able to read the image from - (standard input, which it gets from the standard output of grim), and write the text it finds to - (standard output). Finally, we stuff the text that was found using tesseract into the clipboard using wl-copy, and voilà! We now have the text from some image in our clipboard by just drawing a box around it, and we did it with no temporary files on the disk.

However, calling this from the command line each time you want to select text from an image could become cumbersome if it’s something you want to do frequently. I decided to set this up using a wofi menu, and several options for taking screenshots.

Here is the script that I created:

#!/bin/sh

screenshot_copy_all_displays="Screenshot all displays to clipboard"
screenshot_all_displays_to_file="Screenshot all displays to file"
screenshot_copy_area="Screenshot area to clipboard"
screenshot_copy_area_ocr="Screenshot area to copy text"
screenshot_area_to_file="Screenshot area to file"
screenshot_copy_window="Screenshot focused window to clipboard"
screenshot_window_to_file="Screenshot focused window to file"
screenshot_copy_monitor="Screenshot focused monitor to clipboard"
screenshot_monitor_to_file="Screenshot focused monitor to file"

# Store each option in a single string seperated by newlines.
options="$screenshot_copy_all_displays\n"
options+="$screenshot_all_displays_to_file\n"
options+="$screenshot_copy_area\n"
options+="$screenshot_copy_area_ocr\n"
options+="$screenshot_area_to_file\n"
options+="$screenshot_copy_window\n"
options+="$screenshot_window_to_file\n"
options+="$screenshot_copy_monitor\n"
options+="$screenshot_monitor_to_file"

# Prompt the user with wofi.
choice="$(echo -e "$options" | wofi -d)"

# Make sure that all pictures are saved in the screenshots folder.
cd ~/Pictures/Screenshots

case $choice in
    $screenshot_copy_all_displays)
        grim - | wl-copy
        ;;
    $screenshot_all_displays_to_file)
        grim
        ;;
    $screenshot_copy_area)
        grim -g "$(slurp)" - | wl-copy
        ;;
    $screenshot_copy_area_ocr)
        grim -g "$(slurp)" - | tesseract - - | wl-copy
        ;;
    $screenshot_area_to_file)
        grim -g "$(slurp)"
        ;;
    $screenshot_copy_window)
        grim -g "$(swaymsg -t get_tree | jq -j '.. | select(.type?) | select(.focused).rect | "\(.x),\(.y) \(.width)x\(.height)"')" - | wl-copy
        ;;
    $screenshot_window_to_file)
        grim -g "$(swaymsg -t get_tree | jq -j '.. | select(.type?) | select(.focused).rect | "\(.x),\(.y) \(.width)x\(.height)"')"
        ;;
    $screenshot_copy_monitor)
        grim -o $(swaymsg -t get_outputs | jq -r '.[] | select(.focused) | .name') - | wl-copy
        ;;
    $screenshot_monitor_to_file)
        grim -o $(swaymsg -t get_outputs | jq -r '.[] | select(.focused) | .name')
        ;;
esac

This script does assume that the file ~/Pictures/Screenshots exists. Make sure that folder either exists, or modify the script to save the file in a different folder

This script has a bunch of options that I find useful. You can either choose to save the screenshot to a file, or to the clipboard. You can choose whether to screenshot a region, the focused window, the focused monitor, or all monitors. These could of course all be bound to different shortcuts, but I personally like having a single screenshot button for simplicity.

Speaking of binding shortcuts, lets go over making this script into a shortcut on Sway. I recommend you save this script to a file in your path. I personally have this saved to ~/.local/bin/screenshot-menu.sh. Remember to mark the script as executable using chmod +x.

Make sure to check that the script works properly for you by running the script from the command line. In my case, I can open a new terminal and type screenshot-menu.sh and the wofi menu will appear.

If that’s working fine, you can now add a binding to your sway config to run the script. Add a new line to your config (mine is located at ~/.config/sway/config), for the new binding. It should look something like:

    bindsym $meh+a exec screenshot-menu.sh

The $meh key is a special modifier on my keyboard; you should use something that makes sense for you.

Happy screenshotting!

How to Generate a Vanity Algorand Address

Sun, 28 Feb 2021 11:24:16 -0500

A vanity address is an address that has been generated such that it has some recognizable pattern. For example, if you want to accept Algorand at your business, you could generate a wallet whose address resembles or matches a portion of your business name. Personally, I have an address which matches my nickname, which is quite nice.

To generate addresses, I created this Go program (Repo can be found here).

package main

import (
    "fmt"
    "github.com/algorand/go-algorand-sdk/crypto"
    "github.com/algorand/go-algorand-sdk/mnemonic"
    "os"
    "regexp"
    "runtime"
)

func main() {
    walletChan := make(chan string)
    pattern := os.Args[1]
    for i := 0; i < runtime.NumCPU(); i++ {
        go func() {
            for {
                account := crypto.GenerateAccount()
                go func(acc crypto.Account) {
                    m, _ := mnemonic.FromPrivateKey(acc.PrivateKey)
                    wallet := fmt.Sprintf("%s:%s\n", acc.Address, m)
                    matched, _ := regexp.MatchString(pattern, wallet)
                    if matched {
                        walletChan <- wallet
                    }
                }(account)
            }
        }()
    }

    fmt.Println(<-walletChan)
    os.Exit(0)

}

This script is made available under the 0-clause BSD license

To run this program, you must have Go installed on your machine. I will assume you have it installed for this post. If you need help installing it, you can reach out to me, and I will try to help you get set up.

You can install this by running the following command, which should automatically build and install the dependencies.

$ go install git.robbyzambito.me/robby/vawg/v2@latest

If you have go installed properly, this should add the vawg binary to your $PATH. You can then generate a wallet by passing a regular expression as an argument. Here is an example of running the program:

$ vawg "^H[E3]LL[0O]"
H3LLOVA5RAKHN5ZDL6TMO5UF3XH5VS4UWELAL7UUFWKO6NUFALLK3BPM3I:number frog indicate over verb stable ignore salute leopard loop merit neither attract wrap assume pluck rely firm album deny shield dumb visit absent canal

I advise against using this wallet since I posted it on the internet.

This took about two minutes to run on my machine with a Ryzen 7 3700X. If it seems to hang and eat up a lot of CPU, that means it’s working :)

A few things to note:

Wallet addresses are in full caps, so if you do not pass it a full caps string it will never find a wallet.
The regular expression matches against the whole output. The ^ means that it should match against the beginning of the output. This is usually what you want.
Since it uses regular expressions, you could increase the results you would accept (and potentially cut down on search time) by providing accepted alternatives. This is shown in the example, where a 3 is accepted in place of an E, and a 0 would be accepted in place of an O.

The seed phrase (the sequence of words after the “:”) can be used to add the wallet to whatever wallet app you use.

My Computer Setup

Mon, 01 Feb 2021 00:11:17 -0500

I built my computer after purchasing the parts on Black Friday 2019, with the expectation of programming on it, but also being able to game on it at times. When I program I like to make use of virtual machines, which can quickly make use of a lot of RAM. I prioritized RAM and CPU in my build, followed by my GPU and storage. Below is a list of parts used in my machine.

Part	Item
CPU	AMD Ryzen 7 3700X
RAM	32GB G.SKILL Trident Z Neo
GPU	Sapphire Radeon PULSE RX 590
Motherboard	ASUS Prime X470-Pro
Storage drive	4TB Seagate BarraCuda
External drive	4TB WD Elements (May not be exact model, I’ve had this drive a while)
Boot drive	250GB Samsung 970 EVO Plus
Wireless card	Gigabyte GC-WB867D-I
Power Supply	750W Seasonic FOCUS GX-750
Case	Used Corsair case from a friend, not sure what the model is
Monitor stand	Ergotech Freedom Arm x2
Main Monitor	Atron Vision AVF240 24" 144Hz Monitor
Ultrawide Monitor	Old LG Ultrawide (2560x1080), not sure what the model is
Top Monitor	Used LG 1600x900, not sure what the model is

Recently I added a 2.5" / 3.25" SATA drive bay that allows me to hot swap drives easily. My intention is to use this to install operating systems on physical hardware that otherwise have limited hardware support, like GNU/Hurd. I do this by passing the physical drive to a virtual machine, and then installing the OS in the VM, before removing the drive and putting it back in its original machine.

On the left side of my desk I have my #cofe (often tea as well, I don’t discriminate!). The switch is a 24 port Netgear JFS524, that I actually picked up for free from a garage sale as it was ending. Connected to the switch is a Raspberry Pi 3, and next to that is an Arty A7, which I intend to use to play around with RISC-V. On top of the switch I have my headphone stand, and my box of USB drives. Both of which I made during a woodworking class I was lucky enough to take in high school.

Bonus shot using my phone as a fan to cool the Raspberry Pi.

I am fairly proud of the cable job I have below my desk. It isn’t perfect, but the few cables that aren’t tied up with the rest I often unplug to move between machines (ie my webcam). On the topic of my desk, it is made of a solid core door that my parents had in their garage, and a few 4x4s for the legs.

I purchased a PinePhone which I tried to use for my daily driver for a while, but I was having connectivity issues in my area and had to switch back to my Samsung S10. I plan on replacing my phone plan to switch to a network that I have better connectivity with, so I can ditch my Android phone.

Here are the input devices that I use with my desktop

Device	Item
Mouse	Logitech G602
Keyboard	Corsair K70
Drawing tablet	Huion Inspiroy H430P

The price of the Logitech G602 has risen since I got mine. If you want a mouse like the one linked, the G604 is a newer model and likely a decent option. I tell my self that I will use the drawing tablet to actually draw things, but in practice I have only used it to play osu.

I will make another post going over my software setup soon!

Proprietary Software is Anti-Capitalist

Tue, 17 Nov 2020 07:26:15 -0500

A theoretically perfect market under capitalism assumes that consumers have access to an infinite supply of producers. This allows consumers to inspect the market, and select the product that best fits their needs. In the long term, monopolies erode capitalism, because they meaningfully constrict the market and decrease the options available to consumers. This means that consumers have limited access to a variety of products and services under a market controlled by a monopoly.

A patent is a construct that grants a company a temporary monopoly to produce something. This is based on the assumption that guaranteed monopolistic power for a temporary period can encourage innovation. Some assume that proprietary software licencing can encourage innovation in a similar way. However this is not the case, because the proprietor of a piece of software actually has a permanent monopoly on the marketable actions to that software, such as distribution, repair, and modification.

The key difference between Free Software and proprietary software for the average consumer is not that they have the right to view the source code and learn to repair or modify their own software. The difference is that the consumer can access an unrestricted market of software developers to make the modifications or repairs to the software that the consumer desires. This is no different than a consumer bringing their car to their mechanic of choice in order to repair or modify their vehicle.

Should you be interested in finding support for Free Software, or if you are interested in providing service, the Free Software Foundation has put together a list of services that could provide assistance. You could also reach out to freelance software developers on sites like Fiverr, or Upwork.

You Are Forbidden From Innovating Here

Thu, 12 Nov 2020 09:12:55 -0500

When was the last time you heard of someone creating an innovative technology built on top of the Web?

Since the creation of the Web, there has been an incredible burst of innovation, that still continues today. In contrast, when was the last time you heard of someone innovating on top of Facebook? Maybe you have watched some talk from an engineer at Facebook about technology they created to overcome some problem they ran into, but that’s about it. Innovation on top of Facebook’s technology, occurs at Facebook. If you do not make it past the interview process at Facebook, you are not allowed to innovate.

You might have a great idea for how Facebook could better suite your needs, and even the skills to implement it given the opportunity. Should Facebook deem you “unworthy” of hiring however, it is often illegal for you to implement your changes.

This is a disaster. The hiring team at Facebook should not have the power to decide who has the right to innovate. Free Software is essential because it grants you permission to innovate and create new things with the things you already have.

I believe many people understand the situation backwards. They think proprietary software is a necessary evil because it drives innovation. The opposite is true though: proprietary software leeches off the innovation done by Free Software that had been created before it, and that it is built on top of. Facebook would not have been possible had the Web not been created as a Free protocol for anyone to use and build on top of.

A tangible example of this is Android versus iOS. Let’s say I wanted to build my own smart phone right now, and sell it for a profit. I can use the Android operating system on the device, and even make changes to Android to make it better suite how I expect the device to be used. I wouldn’t need to special permission to do this, and my clients would benefit from having access to the existing ecosystem of applications. In contrast, it is illegal to manufacture and sell a device with iOS installed on it, without the permission of Apple. That’s why there are many companies that manufacture devices using Android, such as Samsung, LG, Sony, Google, etc. and Apple is the only company that sells devices running iOS.

In short, the history of technology is a continuous stream of innovation, built upon previous technologies. Companies have been allowed to become the gatekeepers of innovation in the name of profit. Using Free Software is not breaking the cycle, it is allowing the cycle to continue.

Deleting Social Media with Algorithmic Feeds

Tue, 03 Nov 2020 06:01:51 -0500

Algorithmic feeds are designed with a purpose, to make consumers behave in ways that they otherwise wouldn’t.

About a month ago I decided to deactivate my Facebook account, and to uninstall Snapchat, Instagram, and Slide for Reddit from my phone. I did this because I felt like I was not using the internet on my own terms anymore. I felt (and still do) that handing the power to curate everything I see over to black boxes such as the ones I listed was not healthy for me. As a consumer of algorithmic feeds, you are not allowed to view, let alone control the system that decides what kind of information you see.

As an example, if you wanted to use Instagram as a way to show you content that makes you happy, the most you can do is aggressively suggest to the system that it should show you that content, by searching for it and following users who regularly post related content. For the last 2 years or so, I have tried to exclusively use Instagram for looking up dog photos, videos, and memes, and sharing them with a group chat of my friends. Despite this, I still would have content in my feed that did not align with my desires, such as political content, or other content that would evoke strong emotional responses from me.

As an experiment, I didn’t tell anyone that I was deleting the social media apps that I listed above before doing it. I wasn’t sure what kind of response I would get from those around me for doing this, if any. The first person to notice anything was my girlfriend, who noticed that she couldn’t see my Facebook page. I told her that I decided to deactivate my account, and that was that. To be fair though, I haven’t really been using Facebook for many years, so I figure most people haven’t noticed my page is missing. Snapchat on the other hand has been a little different. I didn’t look into seeing if I could deactivate my account without deleting it, so my account is still accessible to people. I think this may have caused some confusion, since people might be thinking that I’m ignoring them. A friend of mine said that he sent something, and I told him that I haven’t had Snapchat installed for a while now. Again, that has been that as far as my life without Snapchat.

There is this idea that you need to have an algorithm to curate content for you, or else it will be boring. After using my own Pleroma instance as my primary social media platform since July, I can tell you first hand that you do not need to have a timeline showing content in any order other than chronological in order to have meaningful conversation. In fact, I feel like I have been able to have healthier discussions with people of different backgrounds, since I am not being artificially confined to my own bubble. I’m also in complete control over the content that appears in my feed. If I decide that I don’t want to see content from someone anymore, if I stop following them, my server won’t show me their content unless I look for it. My feed on Pleroma is strictly a chronological timeline of posts from the people that I follow, and that is great.

Hello World

Fri, 30 Oct 2020 09:19:45 -0400

I am ditching my old site for this one for several reasons. My old site was built in Vue, and I thought it looked very nice. However because the entire site was built in Vue, it could not be viewed without JavaScript. I don’t have issues with using JavaScript in general, but it seemed a little absured that a site as simple as mine required it to render.

Requiring JavaScript also meant that my site could not be properly archived by The Wayback Machine. I enjoy looking at old versions of websites, so being able to look back on my own website in the future is important to me.

I hope to use this site as a place to publish my ideas, and write about projects that I’m working on. You can get regular updates by following the RSS feed