Communication with animals through symbols?

The ideas below go for any species really – dogs are just convenient.

Dogs can be communicated with via words. A person can say “Fetch”, “Roll over”, “Food”, etc, and a dog can learn to understand what those words mean. However, dogs can’t (I assume) speak human words – I’m guessing their anatomy differs in a way where they can’t say what humans say.

What if, instead of using words to issue commands, a person used symbols/images? Further, what if the symbols were designed in such a way that a dog could easily write down symbols? For example: dipping the paw in paint and swiping left means “food”. Dipping and swiping right means “fetch”.

If I was a dog, and I tried to invent a language, I would have a lot of problems. My main means of communication would probably be through eye contact, body language, and my voice. (Note that dogs use all of these frequently to communicate with their owners.) The dog wouldn’t have paper or pencil/pen, so they can’t write down any ideas they have. They don’t know how paper/pencil/etc are produced, so they can’t create communication tools. But a human could provide those tools to a dog.

If this worked, the dog could communicate its thoughts with humans. Then it would just be a matter of expanding the dog’s vocabulary, and seeing if they could learn how to make sentences. Further, if a group of dogs learned this language, maybe it would be passed onto offspring?

Useful Windows 10 feature: Improved environment variable editor

I didn’t see this listed in any release notes for Windows 10, or anywhere else for that matter, but this appears to be a really nice new feature. Previously, when editing environment variables on Windows, the value for a variable would be a single string. Example:


This makes it a giant pain to see duplicated paths, find typos, etc.

Now, the environment variable editor has been greatly improved. See here:


This makes it a lot easier to see what’s going on in a given environment variable.

This can all be accessed through System Properties -> Advanced -> Environment Variables -> Edit.

Slowing down dictionary attacks by providing inaccurate password input?

I’m sure this has been thought of before, and it’s probably easy to find a way around – kind of a cool idea though:

In computer security, people can do what are called dictionary attacks ( The basic idea (from my understanding) is that, if I want to hack into someone’s account and I have their username, then I can attempt to log in to that account using the most likely passwords from a pre-determined list. The list of common passwords would come from the most common passwords to appear in data dumps/hacks/etc.

In order to counter this attack, a person could set up a huge number fake accounts, with passwords that are never used by actual humans, on different websites which are likely to be hacked. Then, when the passwords are revealed to attackers, the most-commonly-used passwords are not actually used by humans. As a result, databases of commonly-used passwords would begin to have entries for passwords that humans don’t actually use. As a result, it would take longer for the dictionary attack to run through each possible password, and slow down the attack.

It’s kind of a nasty solution, and it probably wouldn’t work, but it’s fun to think about.

Fixing audio popping/hissing for rendered files in FL Studio

Note to self for the future:


When rendering a project in FL Studio, a specific synth (Sytrus in this case) sounds completely different in the rendered version.

  • In this situation, the rendered audio file removed most of the bass frequencies from the synth, and caused a lot of grating popping/hissing sounds.

Notably, when this project was rendered on a separate, more powerful computer, the problem did not occur. This is probably because the less-powerful machine couldn’t handle the data coming from the synth – which is fixed in the Solution.


Increase the buffer length in FL Studio. Go to Options -> Audio settings -> and change the “Buffer length” setting.

Music needs the equivalent of plain-text files

Here’s a small rant:

In software development, the source code (the instructions that define how a program works) is written in what’s called “plain text”. Plain text is basically just a document with human-readable text.

Since software is written in this fashion, software developers have created things such as version control systems. These allow developers to create a project, track how that project has changed over time, review each others’ work, and collaborate very easily. This allows people all over the world to easily work together to make computer programs.

Plain text also allows users to search for keywords throughout documents. For example: open Notepad, type some text, and then press Ctrl+F. Since you can search for text, you can navigate through documents quickly. Other, more complex, searching tools exist as well, such as regular expressions.

Music is an area that would benefit greatly from an increased ability to collaborate. When writing music in a DAW (Digital Audio Workstation), the only method I know of for sharing my work with other users is to email them a project, which they open and edit. This causes a lot of issues when collaborating. For example, if you want to work on multiple versions of a song, the main option is to save two copies of a project with different names. Every time you make a change that you might want to reverse later, you have to save a new version of your project. This is a gigantic, messy hassle. Contrast this to version control: In version control, every change that’s ever been made to a project, along with who made the change and when, is stored for later browsing.

The above is just the tip of the iceberg, in terms of the benefits of switching DAWs to a standard file format. Other benefits include the ability of different musicians to use different DAWs, and still work together. This is a topic for another post, but: if standard libraries of electronic instruments were freely published, and used by music producers, then the libraries could then be distributed to users’ computers, like software libraries. At that point, to listen to a song, you would only need to know the collection of notes and effects to play, at specific times. I’m betting this would vastly reduce the size required to download and play songs, and as a result less storage would be required for music.

How does this need to happen? I’m not sure yet. I’m betting that MIDI messages could be stored in a human-readable way. It’s a tough problem. The benefits from solving it would be great, though.

Using the toe rather than the ball of the foot when climbing

Disclaimer: I’m still a noob, so take the below with a grain of salt.

In the self-coached climber book, it’s mentioned that “For newer climbers, learning to get onto the big toe is important, as this provides the greatest range of motion.” After thinking about this, this makes total sense. So I drew up a quick diagram of what this means.


Click for full-size version

As shown here, when you stand on the ball of your foot, the protruding toe and heel limit the foot’s range of rotation. Also, basically the only way to place your foot is with the inside of the foot facing into the wall. However, when standing on the toe, you get an extra +/- ~1 inch of height that you can adjust, and you can rotate your foot a larger amount around the hold.

The cool thing about this technique is that it’s extremely simple to do – just use your toe rather than the ball of your foot when stepping on holds – and it provides obvious, consistent benefits (extra, adjustable height, and a larger ability to rotate). Hopefully this helps someone – I’m off to start trying this out.

Possible language feature: View Classes

Note: The below post is something I haven’t really thought about a lot. Needs further development and thought before it could be useful probably.

In relational databases, we often work with views. Simply put, a view is a way of representing data that you’re interested in, without directly showing the data’s underlying structure.

In object-oriented programming languages (my experience is mainly in Visual Basic/C#), I can think of no analogous concept for classes. For example, consider this class:

class Customer
    public DateTime DOB;
    public string FirstName;
    public string LastName;
    public string MiddleName;
    public string EmailAddress;
    public string PhoneNumber;

In my application, I will use this class in multiple places. For example, a screen to add Customers would let me create Customers and set all the above fields. Another screen might let me search Customers by name or DOB.

The problem: Everywhere in my application that I deal with Customers, I use the Customer class. However, in most places, I’m only interested in a sub-set of the Customer class (IE: just names and DOB). So areas of my application that don’t care about EmailAddress and PhoneNumber have to retrieve that data from the database, have access to those properties, etc.

A solution: The first solution I could think of would be to make classes that are specific to the problem you’re solving now. For example, if you’re making a Customer searching screen, the model for the screen could be:

class SearchableCustomer
    public DateTime DOB;
    public string FirstName;
    public string LastName;
    public string MiddleName;

However, this is tedious and messy. For every area of the application, you could need a separate model class, where all of the models actually are parts of the same thing.

A (possibly) better solution: Implement a language feature called view classes. Something like this (the syntax is kind of nasty):

class view SearchableCustomer { Customer.DOB, Customer.FirstName, Customer.LastName, Customer.MiddleName }

The “class” can be created in-line, saving you from having to declare a bunch of classes that are only used in one place. This lets you work with classes in a way that’s specific to your problem, without having to declare and maintain multiple classes. There’s one canonical definition of what a Customer is, and multiple ways of looking at that class.

EDIT: A redditor pointed out that this is a case of the MVP pattern. I wasn’t too familiar with the pattern beforehand, but it seems to work for this. Customer is the model. The presenter converts customer into objects that are useful for particular views. I’m still wondering if this could be done on a language level, rather than in code, though.