DEV Community: Owen Gallagher

JavaScript type detection

Owen Gallagher — Fri, 21 Jan 2022 02:44:13 +0000

This is one of those annoying things I have to relearn every time I come back to writing something in JS.

$ [] instanceof Array
true

$ '' instanceof String
false

$ typeof []
'object'

$ typeof ''
'string'

$ typeof new String('')
'object'

$ wow right of course

That, and this.

Multilingual wordsearch generator

Owen Gallagher — Mon, 29 Nov 2021 05:14:22 +0000

Why?

As a language1 learner most recently interested in Korean/한국어, I've been practicing a lot of new vocabulary. Practicing vocabulary can become tedious if I just follow the same kinds exercises (ex. Duolingo, Memrise, physical flashcards) over and over again.

One twist on the flashcards strategy for vocabulary would be a puzzle like a crossword or a wordsearch. Between the two, a crossword is much harder to improvise, as it requires words to share certain letters/characters so they can be organized with crosses.

So, given that they'd be a bit easier to create quickly, I chose to try using custom wordsearches. The plan was to pick a handful of words, maybe by topic, or by difficulty, or randomly, and put them in a wordsearch puzzle together.

... But I couldn't find a good wordsearch generator. There were a bunch I found, but none of them supported different character sets (as far as I cared to figure out).

That's how I decided to make my own.

How it works

At the core of being able to support different languages in my wordsearch generator is the alphabets.json file, which currently looks like this:

alphabets.json

{   
    "en": {
        "ranges": [
            [97,122]
        ],
        "upper_ranges": [
            [65,90]
        ]
    },
    "es": {
        "ranges": [
            [97,122],
            [225,233,237,243,250,252]
        ],

        "upper_ranges": [
            [65,90],
            [193,201,205,211,218,220]
        ]
    },
    "ko": {
        "ranges": [
            [44032,55203]
        ],

        "upper_ranges": [
            [44032,55203]
        ]
    }
}

Valid characters from which to pick random ones when initially randomizing the wordsearch cells are defined by "ranges", though they're more like sets. If I list two values, that means all unicode points between a and b. Any other number of values means all these unicode points a,b,...,z. Being able to list noncontiguous points makes it easy to include sparse characters like accented vowels used in Spanish (see es).2

Once the language alphabet can be defined with this system, the generator is able to fill cells with random characters and later populate some of them with hidden words that the user provides.

My placement algorithm for the hidden words is essentially brute-force. I pick a direction and then try random spots until I find available space, with a maximum number of attempts, beyond which the word is skipped.

How to use it

The current best-supported method of providing configuration/description/input for generating a wordsearch is via a json file, like so:

example_en.json

{
    "language": "en",
    "size": 15,
    "words": [
        "apple:a fruit",
        "skull:head bone",
        "scissors:cuts paper",
        "boat:floats on water",
        "bird:feathers and beaks"
    ]
}

Generating a puzzle like:

Extension

Note that, hopefully, this implementation is extensible enough to easily support other languages (add entries in alphabets.json), including arbitrary character sets.

I'm also considering making a printer-friendly output option in the webpage example so that the generated wordsearch is easy to make into a physical worksheet.

Source code

ogallagher / wordsearch_generator

Multilingual wordsearch (word search) generator

Footnotes

Language here refers to, at least, programming languages and human/natural languages.

In order to also support cases (upper, lower) for alphabets like that of English, I added the "upper_ranges" attribute.

Tetracoords theory - triangular 2D scalar arithmetic

Owen Gallagher — Sun, 08 Aug 2021 20:24:25 +0000

Justification and inspiration

I was originally inspired by the geohash coordinate system, proposed as an alternative to latitude-longitude coordinates for mapping the Earth’s surface, and by later proposals like plus codes. Tetracoordinates are not meant to compete with either of those proposals for use as geographical coordinates, and I hope that plus code or a derivative continues to improve and be more widely adopted for addressing and navigation.

The tetracoords system rather tries to address specific issues with the geohash approach while keeping many of the same advantages, focusing especially on use in software (as opposed to being human-readable).

For example, imagine you’re creating a 2D multiplayer game, where all objects and avatars need to have assigned positions. Using traditional 2D vectors, you then need to determine a scale and precision for that game space. If you use integers, then nothing can be at position 0.5,-0.5 because an integer doesn’t allow for precision at place value 10^-1. If you use floats, then the further something is from the origin 0,0, the less digits its position can allocate for determining precision, and vice versa. These limitations usually mean that the dimensions (and max zoom level) of the game space cannot grow over time.

Using a tetracoord-based datatype, however, you don’t need to specify scale or precision beforehand, and different tetracoords with different numbers of significant digits (of different sizes in memory) can be used for different contexts as needed (a fast airplane has high scale, but a slow ant has high precision).

Below are some key advantageous characteristics of tetracoordinates:

Centered

The origin, marked as cell zero above, is centered. This is crucial for later being able to increase scale (outward) and precision (inward), because the current outermost cell is the center/origin of the next level.

Just as in cartesian coordinates with base-10 numbers, where the more significant (leading) and less significant (trailing) digits can be implied zeros (15 = 015 = 0015 = 15.0 = 15.00), tetracoords can behave the same way.

In a system like geohash, however, since there is an even number of cells in a square grid, then the cell designated as zero, the origin, is not centered, but rather at a corner. If you try to scale outward, then that cell will need to be in the same corner of a larger square, thus only allowing scaling in only two directions.

Note geohash doesn’t typically use only 4 cells per level, but I’ve modified slightly for comparison.

Recursive

In order to scale inward and outward uniformly, the layout of the cells is recursive, as in geohash.

Base-2/binary compatible

Using four (a power of 2) cells per level makes a tetracoord binary-compatible for efficient storage as a datatype in software.

For example, the base-4 tetracoord 0.1.3 is equal to the binary tetracoord 00.01.11.

Determinate

Just as in geohash, tetracoord cells never overlap, so there is only one coordinate mapping for any cell. However, any theoretical point exactly on the border or vertex between cells is irrational and indeterminate, much in the same way that 3/3 equals 0.9999... equals 1.0.

Mathematical nonnegative scalars

Tetracoord values, though they represent locations in 2-dimensional space, are nonnegative scalar values. This means they don’t need to be represented with multiple components as do cartesian coordinate vectors.

Additionally, and more importantly, tetracoords can still support arithmetic operations (addition, subtraction, multiplication, division, etc), though these operations behave according to laws wholly different from both scalar and vector arithmetic in the number systems we normally use.

However, if the algebraic laws and arithmetic patterns for tetracoords are properly defined, then methods can be written to perform tetracoord arithmetic without the need to convert to a different number space (like cartesian space).

Definition

Consider a 2-dimensional space, organized into nested equilateral triangles, like so:

This is the famous Sierpinski Triangle fractal, which ideally would be infinitely large, with an infinite number of subdivisions. In other words, each triangular cell in this infinitely large space is also infinitely small. In practice, however, the implementation of tetracoordinates in a 2D space would always be truncating scale and precision depending on what’s needed.

Now, for creating a tetracoord space, don’t leave the central cells empty, creating a denser (and more boring) version of the fractal. The coordinate value of each cell at each level uses the center cell as 0, and the rest in counterclockwise order, starting with the vertically offset cell, as 1, 2, and 3:

Some cells are left intentionally blank to save myself the effort.

Syntax

Binary and quaternary bases

In this article I switch between base-4 and base-2 representations, which are effectively equivalent.

base-4 (quaternary): 1.3.2.0

base-2 (binary): 01.11.10.00

Of course, other bases could be used for compression or legibility, removing the dot delimiters between levels:

base-4 (quaternary): 1320

base-8 (octal): 170

base-16 (hexadecimal): 78

Delimiters

I use the dot as a place value separator (like ip address byte delimiters), and a double dot after the origin place value (analagous to the point in real decimal numbers).

01.00.10 = 01.00.10.. = 01.00.10..00

..11 = 00..11 = 0..3 (quaternary)

Note that the dot and double dot notation isn’t really necessary when writing tetracoords in base-4, but I’ll use them for consistency.

Algebra

I use a specific notation for algebra, given that at each level there are only four possible values: 00, 01, 10, 11. I use the following variables:

x, y, z, 0

not as placeholders for full tetracoord values, but instead as placeholders for levels within a value. 0 is always 00, but x, y, and z refer to any value other than zero: 01, 10, or 11.

Irrationals

Any point (aka. a cell of infinite precision) on an edge between cells or on a vertex (where edges meet) is an irrational tetracoordinate.

Note that a point along an edge will also be a vertex at a higher specificity.

To denote an irrational number with infinitely repeating digits at each level, I use bar notation, as in:

x̄ ȳ z̄

x.y..y.y.y... = x.y..ȳ

Arithmetic

Tetracoords arithmetic is not intuitive compared to traditional, normal, real numbers, and the rules defined below are derived geometrically, given some basic properties of an equilateral triangle:

Please correct me if I’m wrong in the generalizations below! These are key foundational laws for being able to perform tetracoord arithmetic and later use a tetracoord datatype implementation in programs.

Algebraic laws (so far)

These laws are a work in progress and so far only touch on the most basic arithmetic operations.

0 + 0 = 0

0 + x = x

0 - x = 0..x̄

(note that negatives do, in fact, exist,
in order to allow subtraction, but have
equivalent positive values)

-z = 0..z̄
= x..ȳ
= y..x̄
= z.x..ȳ
= z.y..x̄
= z.0..z̄

x + x = x..x̄
= 2x
= y.z..z̄
= z.y..ȳ
= x.0.x..x̄
= x.y.z..z̄
= x.z.y..ȳ

x.y = x.0 - y

x + y + z = 0
x + y = -z

x - y = y.z

Multiples formula

Just as when performing real arithmetic, there are shortcuts that mathematicians have discovered by studying patterns. For example, to compute 5 * 30 you don’t need to compute 5 + 5 + 5 + ... + 5, but can rather do something like (5 * 3) * 10. Along these lines I’ve determined the following formulas to calculate any positive multiple of x:

k is a real number constant.
x and t are tetracoord values, where a subscript n refers to a digit within the tetracoord.
po(n) means pattern offset formula.
pl(n) means pattern length formula.

Shout out to the math.stackexchange.com community for assisting in the definition of these formulas!

See brainstorming for some messy notes on the derivation.

Below are the results (hopefully) each multiple k*x in set of k = 0, 1, ..., 11:

k	t
0	0.0.0.0.0..0
1	0.0.0.0.x..0
2	0.0.0.0.x..x̄
3	0.0.x.0.x..0
4	0.0.x.0.0..0
5	0.0.x.0.0..x̄
6	0.0.x.x.0..0
7	0.0.x.x.x..0
8	0.0.x.x.x..x̄
9	x.0.x.x.x..0
10	x.0.x.x.0..0
11	x.0.x.x.0..x̄

Future research

Explore more advanced tetracoord algebra (multiplication and division, exponents and roots, rules for decomposition and composition at different levels, etc).

Implement a functioning tetracoord datatype in any programming language that leverages its advantages (variable scale and precision, native tetracoord arithmetic, conversion to and from cartesian vector coords).

Create a GUI 2D map navigator that shows tetracoord cells at different specificities and scales and shows equivalent cartesian and tetra coordinates.

Extend a similar system to 3D and possibly further dimensions.

Brainstorming

Multiples pattern search

Multiples pattern length and offset formulas

Google Drive anonymous animals – Collect them all!

Owen Gallagher — Sat, 12 Jun 2021 03:18:18 +0000

Questions

I’ve always been interested in the animal icons that users are assigned when accessing a Google document anonymously, but only recently did I seriously start wondering:

How many are there?

Are they available via some sort of API or image server?

Searching

So, I began searching the internet. See the end for some related pages I found and stuff I used for reference.

I figured since these animals have been around for years and since Google is one of the biggest names on the internet, that it should be pretty easy to answer these questions...

The image source

But no! Nobody seems to know for sure how many there are. There are many lists of varying lengths out there, and it’s difficult to create a definitive one, as it seems animals have been both deleted and created since their introduction.

After many hours of searching, I still not found anything published by Google itself that lists the anonymous animals, though admittedly I haven’t asked anyone that works there directly.

However, I did look into the source for the anonymous icon image that appears in a doc webpage, and found this:

https://ssl.gstatic.com/docs/common/profile/<animal-name>_lg.png

where lg (large) is the size of the image, though I’ve not checked whether other image sizes are available. So, all possible anonymous animal images are supposedly located at ssl.gstatic.com/docs/common/profile/, though I don’t know of an easy way to list all valid image files under that path.

Well – I thought – maybe I could just guess and check?

My own list

So, I compiled as complete a list of animal names as I could find and attempted to check if each existed, with code like so:

function check_animal(animal) {
  return new Promise(function(resolve,reject) {
    let url = `https://ssl.gstatic.com/docs/common/profile/${animal}_lg.png`
    let img = new Image()
    img.onload = function() {
      // anonymous animal found!
      resolve(img)
    }
    img.onerror = function() {
      // anonymous animal not found
      reject()
    }
    img.src = url
  })
}

The results were promising, but comparing with other lists on the internet I saw that there were some I was missing, because some anonymous animals are actually fictional creatures (ex. unicorn, dragon, nyan cat, jackalope), have special names (ex. dumbo octopus, slow loris), or animals at all (ex. pumpkin)! In these cases, I just grabbed names that other people had shared previously and added them to my list.

Showcase

Now, if you’d like to see what may be the most complete list of Google Anonymous Animals on the internet, check mine out at o.dreamhosters.com/anonymousanimals!

Notes

So far, any time an animal has a space in its name (ex. nyan cat, slow loris), the corresponding filename has no space (ex. nyancat_lg.png, slowloris_lg.png).

See zoo.json for my list of animal name candidates that are used to discover anonymous animal images on Google’s server.

Source code for my anonymous animals page is available at github.com/ogallagher/google_drive_anonymous_animals.

References

wayou.github.io/anonymous-animals
a-z-animals.com/animals – I just scraped an animal list from this site for my initial attempt at animal discovery.
jeffersoncheng.com/anonymous-animals - This designer was contracted to design many of the anonymous animals.
musesrealm.net/deities/creatures – I scraped an initial fictional animals list from this site.
medium.com/@roeder
mentalfloss.com, by Claire Shefchik

Collect them all!

If you are aware of other anonymous animals that don’t appear in my list, let me know and I’ll add them!

Define sinstructor

Owen Gallagher — Fri, 30 Apr 2021 02:49:28 +0000

sinstructor (n)

Computer code in any object-oriented program that defines new members of an object instance outside of its constructor, resulting in unnecessary confusion and forgotten variables.

class Vehicle:
    # a happy constructor
    def __init__(self, wheel_count):
        self.wheel_count = wheel_count
    # end __init__
# end Vehicle

motorbike = Vehicle(wheel_count=2)

# CAUTION: SINSTRUCTOR AHEAD
motorbike.color = '#ff0000'

// a happy constructor (sort of)
function Vehicle(wheel_count) {
    this.wheel_count = wheel_count
}

let motorbike = new Vehicle(2)

// CAUTION: SINSTRUCTOR AHEAD
motorbike.color = '#ff0000'

Is this a new term? I derived it by taking constructor (with) and switching it to sinstructor (without).

Relational tags

Owen Gallagher — Wed, 24 Mar 2021 04:40:23 +0000

Why not?

Let's combine the best of two disparate organizational systems: tree hierarchy, and tags.

tree
- Very intuitive for grouping, and maintaining a spatial metaphor (ex. file system with folders, geolocation with quadrants).
- Memorable relationships between entities, permitting easy search by incrementing specificity (users > myself > images > cats > fat_cat.png).
tags
- More improvised/ad hoc approach, where organization evolves organically without knowing what is more or less specific.
- Less rigid classification than the hierarchy tree, with loose relationships.

Relational tags would have the flexibility of tags, with an additional layer of association by defining relationships between tags. I wonder if something like this concept is used in applications like knowledge graphs and mapping natural languages.

For example, I’ll organize the following entities according to the three systems. Note there are certainly many ways to do so:

apple, banana, cat, dandelion, grass, 
mouse, school bus, strawberry, Rudolph

Tree example

- alive
    - plant
        - yellow
            - banana
            - dandelion
        - red
            - apple
            - strawberry
        - green
            - grass
    - animal
        - cat
        - mouse
        - Rudolph
- inanimate
    - school bus

Note, for example, that I didn’t put school bus in yellow because it’s only allowed to have one parent node. A filesystem typically gets around this with aliases/symbolic links/shortcuts/etc.

Tags example

- apple - fruit, plant, alive, red, sweet
- banana - fruit, plant, alive, yellow, sweet
- cat - animal, alive, mammal, carnivore
- dandelion - plant, alive, yellow, flower, bitter
- grass - plant, alive, green, bitter
- mouse - animal, alive, mammal, herbivore
- school bus - inanimate, yellow
- strawberry - red, plant, red, sweet, alive
- Rudolph - alive, animal, red, fiction, herbivore, mammal

Note here that adding new entities to this system becomes tedious, and entity-tag assignments are easily forgotten.

Relational tags example

Tag relationships

These could be directed or not; I’m not sure which is more useful.

alive --> animal, plant, animate
inanimate
color --> red, yellow, green
animal --> mammal, carnivore, herbivore
plant --> fruit, vegetable, flower
fruit --> sweet
flavor --> sweet, bitter
existence --> reality, fiction

Entity-tag assignments

Apple - plant, fruit, red
Banana - fruit, yellow
Cat - mammal, carnivore
Dandelion - flower
Grass - plant
Mouse - mammal
School bus - yellow, inanimate
Strawberry - fruit, red
Rudolph - animal, fictional

Hooray! Now, an entity can belong to any number of tags, and tags have relationships with each other, so I don’t need to remember to add alive and plant to all of my fruit entities.

If I change my mind about the tag relationships, I can easily redefine them.

If I want to search for entities, I can search by tags and the tag relationships will pull in entities assigned to related tags as well.

P.S.

This is more a discussion/opinion thread than anything else.

Is this a new concept, or a new application for an existing concept, or neither? The most immediate application I can think of from a user perspective is a computer’s file system, where the strict tree structure can become cumbersome.

If you’ve seen this implemented in an existing operating system or software framework I’d much like to know about it.