Some years ago I was working on interlocking board game tiles so that you could have a small box that would turn into a large game. Some point between then and not it occurred to me that each side of each hex needed to have 2 connection points, not one.
One day, suddenly, we couldn’t reload a production backup. Oh no! It took a bit of digging around but here is the issue, should you find yourself running into it:
Using the InnoDB COMPACT ROW_FORMAT, there are some rules InnoDB uses to decide how much data to put on the first page and how much to put on overflow pages. While VARCHAR and TEXT type columns are typically stored on overflow pages with no problem, when using the COMPACT row format, up to the first 767 bytes of each field will be stored on the primary page.
This error happens when the amount of actual data exceeds the allows limit for a row size on the main page, which is about 50% of the innodb_page_size variable.
If you have a circumstance with say, 11 TEXT or VARCHAR fields, each with at least 767 bytes of data, and running an innodb_page_size of 16k (which results in 8126 being max row size on main page) …… then 767*11=8437 stored on main page is greater than 8126 which is the “maximum allowed size for a record on index leaf page”, and you will get this error.
The solution is to investigate the use of either DYNAMIC or COMPRESSED row format, depending on your application.
If you need a super easy way to reset your MySQL or MariaDB root password because you locked yourself out, this is how it can be done.
- Login as root@yourhost
- Shutdown any remote access as your server will be without password for a few moments.
- Edit /etc/my.cnf, and under the [server] section, add
- Restart MySQL
- Login and update the password with a query like this:
# mysql MariaDB> use mysql; MariaDB> update user set Password=PASSWORD("yourpass"), authentication_string=PASSWORD("yourpass") where User='root';
- Remove the “skip-grant-tables” line from /etc/my.cnf
- Restart mysql
You are back in action! Don’t forget to re-enable remote access.
Recipe for really outstanding hot cocoa:
- 4 cups milk
- 1 can sweetened condensed milk
- 1/2 cup cocoa powder
Put it on the stove and stir until hot and dissolved. It is very rich and exceptionally chocolaty.
Microsoft has been doing a lot to promote linux interoperability on windows. I see this as a great step in the right direction, after decades of a closed and exclusive culture that has been a pain for cross-os users like myself.
Here is a quick and dirty rundown of how (March 2019) to install Ubuntu on Windows 10:
See here for the full rundown: https://docs.microsoft.com/en-us/windows/wsl/install-win10
Install the Windows Subsystem for Linux
Before installing any Linux distros for WSL, you must ensure that the “Windows Subsystem for Linux” optional feature is enabled:
- Open PowerShell as Administrator (search for Powershell, right click, run as administrator), and run this command:
Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux
- Restart your computer when prompted.
Install your Linux Distribution of Choice
Go to the Microsoft Store and search for Ubuntu. Install it.
Once you are in Ubuntu, there are a few things to do that will make everything nicer…
sudo apt-get dist-upgrade
sudo apt-get install openssh-server
sudo service ssh start
Fix character encoding issue (until this is fixed upstream)
sudo gunzip –keep /usr/share/i18n/charmaps/UTF-8.gz
sudo dpkg-reconfigure –frontend=noninteractive locales
chmod 700 .ssh
chmod 600 .ssh/authorized_keys
Fage Total whole milk plain yogurt with home made peach jam.
Here is a basic introduction to immutable and immutable types in python.
In python there are two types of data… mutable and immutable. Numbers, strings, boolean, tuples, and other simple types are immutable. Dicts, lists, sets, objects, classes, and other complex types are mutable.
When you say:
a = [1,2,3] b = a
You’ve created a single mutable list in memory, assigned
a to point to it, and then assigned
b to point to it. It’s the same thing in memory.
Therefore when you mutate it (modify it):
b = 3
It is a modification (mutation) of the index
 of the value which
b points to at that same memory location.
However, when you replace it:
b = [0,0,0]
It is creating a new mutable list in memory and assigning
b to point at it.
Check out the
id() function. It will tell you the “address” of any variable. You can see which names are pointing to the same memory location with
Bonus: Every value in python is passed by reference… meaning that when you assign it to a variable it simply causes that variable to point to that value where it was in memory. Having immutable types allows python to “reuse” the same memory location for common immutable types.
Consider some common values when the interpreter starts up. You can see here there are a lot of variables pointing at the memory location held by
abc. cpython, at least, is smart enough to realize that the value `abc` is already stored in memory and because it is immutable, just returns that same memory address.
>>> import sys >>> sys.getrefcount('abc') 68 >>> sys.getrefcount(100) 110 >>> sys.getrefcount(2) 6471
However, a value that is definitely not present would return
2. This has to do with the fact that a couple of references to that value were in-use during the call to
>>> sys.getrefcount('nope not me. I am definitely not here already.') 2
Notice that an empty tuple has a lot of references:
>>> sys.getrefcount(tuple()) 34571
But an empty list has no extra references:
>>> sys.getrefcount(list()) 1
Why is this? Because tuple is immutable so it is fine to share that value across any number of variables. However, lists are mutable so they MUST NOT be shared across arbitrary variables or changes to one would affect the others.
Incidentally, this is also why you must NEVER use mutable types as default argument values to functions. Consider this innocent little function:
>>> def foo(value=): ... value.append(1) ... print(value) ... ...
When you call it you might expect to get
>>> foo() 
However, when you call it again, you prob. won’t expect to get
[1,1] out… ???
>>> foo() [1, 1]
And on and on…
>>> foo() [1, 1, 1] >>> foo() [1, 1, 1, 1]
WHY IS THIS? Because default arguments to functions are evaluated once during function definition, and not at function run time. That way if you use a mutable value as a default argument value, then you will be stuck with that one value, mutating in unexpected ways as the function is called multiple times.
The proper way to do it is this:
>>> def foo(value=None): ... if value is None: ... value =  ... value.append(1) ... print(value) ... ... >>> >>> foo()  >>> foo()  >>> foo() 
As we clean up wood stain from brushes and equipment it contaminates the paint thinner used in the parts washer. The good news is that most of the stain settles to the bottom.
Here is a “funnel” that we designed and had fabricated by Anything Metal in Altoona. It will allow the solids to flow to the bottom overnight, and then we can draw them off and properly dispose of, while dramatically reducing the amount of paint thinner we need to dispose of.