RSS has been added to the blog!!

2026-06-18T00:00:00+00:00

I finally got around to enabling feed generation in Zola! you can click the RSS Icon in the navbar or click here</a> to go to the atom.xml file!

Items of known dimension

2026-04-11T00:00:00+00:00

Ever need to measure something and don’t have a ruler or any other tool on hand? Here is a list of common mass produced and standardized objects and their dimensions:

!note: 10mm = 0.3937“, 1“ = 25.4mm

in putting together this list, at the very end, I found this amazing website that’s like this blog post but so much more! Go check out Dimensions.com</a>!!!

Batteries</h1>

AA:

14.50mm (0.571“) wide</li>
50.50mm (1.988“) from flat to nipple</li>
49.20mm (1.937“) barrel length</li>
data sheet</a></li> </ul> </li>

AAA:

10.50mm (0.413“) diameter</li>
44.50mm (1.752“) from flat to nipple</li>
43.30mm (1.705“) excluding the nipple</li>
data sheet</a></li> </ul> </li>

9volt:

26.50mm (1.043“) wide</li>
17.50mm (0.689“) thick</li>
48.50mm (1.909“) tall from flat to terminals</li>
46.40mm (1.827“) tall from flat to flat</li>
data sheet</a></li> </ul> </li> </ul>
Paper items</h1>
ISO sizes</h2>
interestingly the ISO A series sizes are defined by all having an aspect ratio that is the square root of two. A0 has an area of 1m sq. A1 half that, and so on. The B series is the same aspect ratio, but is defined as having an area that is the geometric mean between the steps in the A series. A-series chart</a> B-series chart</a>

A3: 297mm by 420mm (11.7“ by 16.5“)</li>
A4: 210mm by 297mm (8.3“ by 11.7“)</li>
A5: 148mm by 210mm (5.8“ by 8.3“)</li>
B4: 250mm by 353mm (9.8“ by 13.9“)</li>
B5: 176mm by 250mm (6.9“ by 9.8“)</li> </ul>
see the full list on wikipedia</a>
USA common photo sizes</h2>

4“ by 4“</li>
4“ by 6“ (common post card size also)</li>
5“ by 7“</li>
6“ by 8“</li> </ul>
other paper things</h2>

USA letter: 216mm by 279mm (8.5“ by 11“)</li>
credit cards: 85.60mm by 53.98mm (3“3/8 by 2.125“)</li>
USD dollar: 156mm by 66.3mm (6.14“ by 2.61“)</li>
post it notes: common post it is 3“ by 3“ but some of the special ones like the transparent post-its are 2“7/8</li>
receipt paper: 2“1/4 (57.15mm) or 3“1/8 (79.375mm) wide in the USA</li> </ul>
Other</h1>

soda cans

12.2cm (4.8“) tall</li>
6.62cm (2.6“) diameter</li> </ul> </li>
smartphones: see this list from dimensions.com</a></li> </ul>

sms and mms from the computer

2025-08-05T00:00:00+00:00

what is sms mms?</h1>
We tend to think of sms as simply a synonym for texting. In reality texting has been multiple protocols over the years. SMS was the early days, text only, limited to 160 characters. MMS (multimedia messaging service) added the ability to send photos, and today RCS (rich communication service) has been continually rolling out since ~2017.

Anatomy of messaging:</h1>
There is all the typical cell infrastructure used to make calls, in addition we have messaging service centers that improve the network’s ability to deliver messages by saving the data and resending it in the case that a target phone does not acknowledge receipt of the message. These service centers can have different forwarding policies and make no guarantee of transmission since texting is a “best effort” service. We also have sms/mms/rcs gateways that enable interoperability between communication formats/devices for example: email to text conversion. This is also how we can send a text without a mobile handset. Each gateway has one or more SIM numbers that it can use to send messages along the network on behalf of its users. Occasionally a particular business can make a contract with a network provider to connect directly to their messaging center as a gateway rather than using an intermediary, this is really only done in the case of extreme message volumes. There is also the Home Location Registry which is a central database of every SIM and its service information, including its current service area.

Gateway options</h1>
There are many SMS gateway options, but not all of them are suitable for every purpose. For example: JMP offers an XMPP to SMS gateway as part of their service, but that their network contract restricts that gateway to purely personal use, no automated messages. There are also tools that allow you to connect to your phone and use it as an sms gateway. If a target number’s carrier is known, many carriers offer a free email gateway that we can use.
The options we’ll examine are:

kannel</li>
playsms</li>
jasmin</li> </ol>
The above tools let us run a server that we can connect to in order to forward messages (the gateway) but they themselves are unable to send an sms directly, they need a connections to some sort of smsc/gsm modem. To use any of these we may need to obtain a gsm modem, it looks like we can find one online for less than $20, though we probably still need to pay for a SIM plan. Ideally I’d like to use a pre-existing phone as the smsc/modem.
Other tools</h1>

gammu</li> </ol>
Some other commercial products that could be used:</h1>

google messages</li>
apple message sync</li>
twilio</li>
plivo</li>
infobip</li>
maybe kde connect</li>
mautrix-imessage</li>
straight up ios shortcuts has texting capabilities</li> </ol>
try looking some stuff in the app store too. twilio charges per message and is about 1 cent.

Summary of three shorthand systems

2025-03-27T00:00:00+00:00

Teeline</h1>
First, we have Teeline which is designed for easy adoption by virtue of using simplified letterforms to gain speed rather than phonetic spelling. Though it does introduce its own family of abbreviations.

Gregg</h1>
Next we have Gregg, a phonetic system. While Theoretically this allows faster transcription since one doesn’t need to retrieve exact spelling from their mind, in fact phonetic shorthand systems almost always rely on consistent phoneticization and come with whole dictionaries of transcriptions for common words. So in addition to learning a new way of writing you must learn the Gregg Accent.

Pitman</h1>
This is the oldest of the three and shows its age. It is designed to be written using a pen with a flexible nib such that the writer can precisely control the thickness of their line. It uses phonetic spelling, but like gregg it’s phonetic to a specific accent, in this case one that’s a little old fashioned.

A foray into woodcut printing

2025-03-01T00:00:00+00:00

This week, thanks to my friend’s help reorganizing my workspace I dipped my toes into woodcut block printing. I’d previously avoided print methods that involved carving because I didn’t like the equipment threshold it required, but I recently got a nice and relatively cheap carving set and have a bunch of doorskin lying around so I decided to give it a shot to make a little gift for my friend’s birthday.

The Design Process</h1>
The project scope was to creat a business card print for a sort of indiana jones type character. I started by tracing out a business card onto a sheet of paper, marking out the margins, and then iterating on the design.

I liked the idea of using a heavy western font that really dominated the space so I went with that design and drafted the letters as evenly as I could with my limited experience. I then needed to fill the interior space and experimented with a couple ideas. After some carving tests I realized I wouldn’t be able to handle the small details of fine text and stuck with a simple “ESQ.”
In order to fix alignment, I traced my winning draft onto a new piece of paper, offsetting it slightly as I went in order to bring everything into place.
I spent quite a while drafting out different takes on the little “ESQ” title. I needed it to be squat enough to not butt up against the top or bottom text while still being legible and carvable. I originally wanted to do a sans serif monoline font with an oval outline. I ended up scrapping that idea because the fine carving required between the oval and the letters seemed too risky and time consuming since I didn’t want to have to start over and didn’t want the project to stretch out more than the time I’d budgeted. From a design perspective I also wanted to lend more weight to “NICK DANGER” and putting “ESQ” in an oval meant that it became dark and detailed and pulled too much attention. It also left too much negative space on either side. I added back some slight serif to the letters because without them it didn’t seem to fit the retro style quite as well.

I then traced out a little block for the space ESQ would take and iterated a bunch of times. I really struggled with finding a “Q” that was legible and fit in the space, ultimately I don’t think I quite succeeded, in retrospect I think extending the beginning of the tail past the left edge of the round part could have helped legibility. While the letters fit stylistically, looking at the finished prints I think they still take too much visual weight and aren’t clearly distinct enough from “NICK DANGER” I would say that it should have been smaller, except given this was my first time using these tools I was already working at the edge of my abilities without risking needing to start over. perhaps thinner line weights or making the name white on black instead could have helped.
In order to add more black around the letters I added in the border stripes above and below. I also began experimenting with different decorations to take up the negative space in the middle and around “NICK”. I used another sheet of tracing paper to overlay these designs and swap them around. Eventually I settled on some lines and interpuncts.

The Carving Process</h1>
The above is a test piece I did in a small piece of doorskin plywood with a design drawn directly onto the surface of the wood. From here I realized that I had forgotten about mirroring the design for block printing. I also discovered exactly how difficult smaller text was to carve. 
While talking about the project someone with woodburning experience suggested using basswood instead, I got a small 1/8“ piece on my way home and it carved much easier so I used that for the final version.
I painted the wood surface white, and then used a stylus to transfer the graphite from my tracing paper to the wood. 
I used double sided tape to hold the workpiece down and started my carving by scoring around each of the letters as a guide and then wherever possible using a flat chisel up to the score line. I also made ample use of a wide U-gouge and an angle gouge for tight spaces.
I’ve since learned that the tradition is primarily to ship carve around linework and obly use gouges for bulk removal or texturing.
The last step was to glue the basswood onto a plywood backing since on its own a thin sheet of basswood is not stable and would warp from the moisture of the printing ink.

Keeping your soul alive

2024-12-16T00:00:00+00:00

Life is hard, and you may find yourself fundamentally anxious and exhausted and broken. When this happens, untangling yourself is horrid and difficult work. No matter what, coming out of the haze will be slow.

tip #1 use your microwave</h1>
A microwave is a beautiful tool that can cook you oatmeal, a potato, broccoli or reheated lasagna in less than 5 minutes. This will keep you alive. Sometimes it can even look really good. If you don’t eat for a while eating will, 1 spike your blood sugar, 2, make you even more hungry. It might make you feel broken, you are not, this is part of the operation of the body, try to eat more if you can.

you will do less than you think you should, you are doing way more than you think you are.</h1>
I kept a log for about two weeks of every activity I did in a day, including watching tv, even on days when I felt like I did nothing I still usually hit about 15 things with 30 on a high energy day. On a day where it feels like you can’t do anything let your body rest, you are doing lots of things you just don’t think they count.

take control</h1>
Be loud, take up space, modify your environment, anything to prove you are real.

build self trust</h1>
This means QUIT. This means EAT. This means REWARDS. Inside you is a horribly scared little toddler mouse, it is impossibly weak, it relies on you for everything. Every time it’s hungry and you refuse to feed it because you haven’t earned the right, every time you tell yourself you’ll stop working and then keep going, every time it says “that was hard I want a lollipop now” and you don’t let it have one because you don’t deserve a lollipop, it will throw up and cry and bawl and beat against your chest. “BUT YOU PROMISED!!!! BUT I WANT TO GO HOME!!!! BUT I WANT TO GO TO BED!!!! BUT IM HUNGRY NOW!!!” and if you let it cry it out every single time, eventually it will fight you, and it will win. Because, that little mouse is your core and it will cut off energy to everything to make you stop and take a break and eat nice food and get a hug if it needs to.
When it does the nuclear option, that’s burnout. And when, you try to fight through burnout and bargain with the mouse it will not listen because you have never held up your end of the bargain anyway and so it won’t trust you anymore. You have to prove to the mouse that you can be trusted. You have to stop when its time to stop, and eat when you’re hungry, and get as many hugs as you can, and celebrate any time you achieve your goals.

making learning easy</h1>
A huge part of inescapable malaise is we feel stagnant. Learning staves off stagnation. Practice new skills to feel like you’re making progress. The quick and dirty version of learning quick is:

try out the simplest version to get a feel</li>
maybe look some stuff up if you have specific questions</li>
play around a bit more feeling your way toward some small, tangible goal</li>
change your goal and go again</li> </ol>
DO NOT FOCUS ON THE END PRODUCT OF COMPETENCY. Focussing on some imagined final competency is a ticket to comparison hell. Focus on the process, let your mind relax and try stuff out, you want to explore the possibility space and, in doing so, you will discover a bunch of different ways to do the little thing you want.
help other people when you can</h1>
This one’s the hardest one for me. It can be really hard to believe you have anything to offer to other people, but you do. Even if its just a friendly presence. Being able to help others gives you evidence of your own worth, allows you to feel wanted, and to form positive connections.
unfortunately you are in charge of fun now</h1>
There’s no official recess time anymore, you have to give that to yourself. Go out and chase geese, play tag, climb a tree. These are all things we do as kids and stop doing at some point when we “mature”. unfortunately, a lot of us aren’t taught any replacements. If you don’t have any replacements, keep doing the kid stuff. Some more “adult” replacements are: folk dancing, martial arts classes, rock climbing, any field sport.
your day in the sun</h1>
Forcing yourself to go outside is hard. especially when people act like a twenty minute walk every day is going to cure depression somehow. It won’t. But, Seasonal Affective Disorder is at least partially because of lack of sunlight, so if nothing else try to sit by a window, I try to walk to lunch or breakfast once a day.
be around people</h1>
When you are alone too long, your brain’s threat model gets really out of whack and it starts interpreting almost everyone as a threat. It’s also no longer getting regular proof that people are totally fine. You don’t have to socialize, but find an excuse to be in an area where you are likely to see at least 8 other people across the time you’re there, and let your body observe that none of them tried to stab you or call you a stinky doodoo head.
your friends are not your parents</h1>
Unlike your family, your friends didn’t just wake up one day with you stuck in their lives. It can be hard to believe you are attractive to anyone, but your friends choose to hang out with you and they do that because they get something satisfying out of it. Your friends are more than ok with the version of you right here right now, and they will be happy to see you happier too.
sometimes anger is really useful</h1>
Anger and dread are your body’s way of saying something is wrong. Listen to it and try to eliminate or reduce your exposure to the problem. Maybe that means blocking someone on twitter, maybe that means dropping a college class, maybe that means breaking up with someone.
listen to the mountain goats</h1>
It’s a good band and John Darnielle is a good song writer.

how to learn stuff

2024-12-14T00:00:00+00:00

Where I got this from</h1>
This post is primarily a way for me to summarize and consolidate what I’ve learned from Barbara Oakley’s “Learning How to Learn”. I also incorporate advice I’ve gotten from professors, from personal reading, and experience.

what to do and why</h1>

learn in building blocks</h2>
Everything we know is built out of mental chunks. These chunks are bits of mental data bound together by shared use, context, or meaning - think microskills or phonemes to words. Once disparate pieces of knowledge have conglomerated into a chunk it is treated as a single unit by the brain and it takes little effort to recall and use it. Chunks take so little effort to use that they can become part of the base knowledge that the brain links together into another chunk.
When you learn how to skateboard, you don’t just “learn how to skateboard.” First, you learn how to position your feet, you learn how to squat, you learn how to shift your feet; then you learn how to use all those skills to push forward and to brake. Then, when learning to skate switch you don’t start with learning how to swap feet while moving. You start with learning how to balance while leading with your non-dominant leg.

Mix up your learning</h2>
When reading documentation for a software product I often find myself frustrated by the fact that I can’t understand how the part I’m reading about fits into the whole, or form even a vague systematic view of the knowledge base. By jumping around the target knowledge area, we can interleave many sub areas of knowledge and begin to see how they fit together before any one part is fully congealed, allowing us to form a clearer more systemic understanding of the whole. Think of it like loading an interlaced image vs an uninterlaced image. The interlaced one loads a lower resolution of the image faster, and then refines it as more data comes in, as a result we can view and understand the image well before it’s done loading. An un-interlaced image that loads line by line may load each segment in perfect detail, but it takes much longer for that detail to become legible, since we have less of the image to work with.

Connect your knowledge</h2>
Knowing things is a snowball process. The more you know, the easier it becomes to learn something new. By looking for way’s we can analogize or relate what we’re learning to what we’re already familiar with we can help ourselves organize our knowledge for retrieval and build that snowball. Metaphors, mnemonics, and visualizations are all useful tools here. We can also link knowledge by context. Learn about the historical context of what we’re learning about and what it was a response to.

Process over product</h2>
We’ve all heard some aphorism about loving the journey not the destination, the doing more than the achieving, so on and so forth. These aphorisms are often presented as some sort of moral truism to follow. Such a presentation annoys me and I’m not in the habit of following advice that annoys me. Here’s the amoral case: THE BRAIN IS LAZY. Thinking is calorically intense and our body wants to save energy on every occasion. A process can become a low energy routine, an outcome cannot.
We talked earlier about how chunks convert the hard work of recalling lots of information into the low effort work of recalling one unit of information. Routines are another example of this same chunking. We can chunk a process, making it easy. We can’t chunk a product, in fact by focussing on the product we’re making it even harder for ourselves because we constantly need to evaluate how close we are to our goal and what needs to be done. By focussing on the doing we can learn and chunk out a routine that lets us offload action to our subconscious.
In other words: if you want to learn to play guitar, focus on playing notes and chords and stringing them together, don’t focus on nailing a perfect rendition of “through the fire and flames”.

have a quitting time</h2>
A common piece of productivity advice is to just work on something for a few minutes and then the momentum will carry you through, this is often paired with mentioning the Pomodoro method and how 25 minutes of work followed by a 5 minute break will make you somehow crush your deadlines. If you’re like me, this is not true. In fact it is actively detrimental to building your capacity.
Any act of self deception is going to hurt us, even if we do it to protect ourselves, even if it does protect us. If you tell yourself, as I once tried to, that “oh I’m only going to work for 5 minutes and then stop” while secretly hoping and planning on momentum kicking in and carrying through, some part of you will know you are lying to it, and it will stop trusting you. Some part of you will feel betrayed when you keep working past the five minutes. Some part of you may say 5 minutes isnt enough of a break, it will say “I can’t even get to the break room and back in 5 minutes” and will grow resentful that it works with no reward.
I spent years ignoring these parts and as a result they stopped listening to me. I had lost my ability to trust myself and my own psyche was in active rebellion against me. Loss of self trust makes us anxious, it makes us second guess and agonize over every decision, it shatters self confidence, it makes accomplishing even basic tasks hard because we no longer truly believe in our ability to achieve any of the requisite steps.
Once we are in a place of low to no self trust, if we want to be able to feel functional again, we have to pick a time when the work ends and we have to stick to it. Over and over again. If we say I will work on this for two minutes and then stop. We stop after 2 minutes, even if we think we got nothing done. we stop at 2 minutes and we do this over, and over, and over, until all those worn out distrusting parts can trust us again, and we have to keep that trust.
Any hardship is easier to endure if we know exactly when it will end.

The real, not torture Pomodoro method</h3>
The power of the Pomodoro method is that it gives us a quitting time. We can tell ourselves that, “after two pomodoro cycles I will not have to do this again today” and mean it. If after those cycles we’re not done, do two more tomorrow. The other power is we get to reward ourselves for our work. That doesn’t mean a 5 minute break. A lot of the time what we’re trying to do is hard and draining work, a short break seems profoundly unsatisfying. If our reward feels unsatisfying, then it’s not going to generate the dopamine that actually rewards our brain. So ignore the break and find an actual reward, maybe go get a coffee, or play a level of a video game or something.
The loosest version of this system is pick a time period that feels light and manageable, work for that long, recuperate, and reward yourself for a job well done. Repeat that until your quitting time for the day, then QUIT.

Consult other people whenever you can</h2>
There’s lots of institutional knowledge out there that very sadly (and sometimes for malicious reasons) cannot be acquired from a book. A lot of that knowledge is very useful and will save us a lot of trouble. There is no way to learn it without consulting with other, more experienced, people, people who remember learning what we’re now trying to learn. If we try to learn everything ourselves from scratch, we will trip and fall many times before we learn to walk, get lost in the woods before we stumble onto the path and so on. We are all greatly advantaged by having someone to consult with even for just a few moments that can point out ruts we might fall in, guide our technique, and provide a roadmap of what we need to learn.
If we try to learn everything on our own, we might by chance discover a few things in the process of fumbling in the dark that noone has seen before, but, by and large we will find ourselves laying the foundations to a cathedral already built elsewhere. Whenever possible, go to the built cathedral and climb the stairs.

Experiential learning can only be learned by experience</h2>
In the world of sports coaching there is a paradigm referred to as Environmental Dynamics or the Constraint Lead Approach. The problem with conventional coaching that CLA aims to solve is one, that any conceivable drill regimen can’t capture the infinite possibility space of an actual game, two, controlling the body’s movement with the speed and precision necessary for sports performance is incredibly difficult to capture in language.
What a constraints lead approach proposes is: that we have an automatic understanding of how to move our body and build fine motor skills through subconscious neurological adaptations, therefore we train a player not by telling them how to play better, or by telling them what better play looks like, we train them by altering the constraints of the game and its environment to encourage developing the skills they need to improve. For example, if we have a baseball player that is hitting the ball too low, avoid instructing them in the minutiae of how to tense their shoulders or where on the ball they should aim to make contact. Put a wall in front of them and tell them to hit the ball over it. The player now has a way to instantly and intuitively evaluate their performance and can automatically explore their movement space to find an efficient solution. Another example might be to eliminate part of an athlete’s movement. If a swimmer’s kicks seem weak we might give them a flotation device to hold with their hands and tell them to only move by kicking until their speed improves.
Note that this approach only works in a situation where the fundamentals of our domain come to us automatically. We don’t learn to code by typing into a text document until we chance into writing valid Python. But, once we are familiar enough with Python’s syntax, keywords, and standard library that we can begin to easily and automatically explore solutions to problems without having to consult a syntax guide, we can improve our code style and efficiency through similar constraint lead exercises. For example, we might practice eliminating nesting by telling ourselves we aren’t allowed to use an if-statement in our solution, or we might force ourselves to work purely within an object oriented or functional paradigm for a while.

practice retrieval</h2>
What we call skill acquisition is at its core, automatic memory retrieval. When the neural pathway for a certain memory is so burned in that activating and using that information happens unconsciously. Immediately after learning something, try to remember it. Maybe we read a book chapter, before going to take notes we should take thirty seconds to recall as much of what we read as possible. This applies to meetings, coaching, and anything else.

Take days off</h2>
Information enters long term memory from short term memory via a process called consolidation. Consolidating a memory once isn’t enough to wear in the neural pathways and retrieval will still be difficult and inefficient. If we want to build up automatic recall we have to practice retrieving the memory from long term storage and then reconsolidating it. What this means is we have to let information leave short term memory, and then recall it back and let it leave short term memory over and over again to build up the pathways for that information. Typically, this retrieval practice is called spaced repetition, this often looks like using flash cards once a week or once a month, or drilling our sport of choice on a regular basis. If you’re like me, doing something at the same time once a week or once a month outside of work can be intimidating, difficult, or soul crushingly boring. Instead I would recommend re-framing from spaced repetition to taking breaks.
We can spend a few hours practicing a skill one day, then take a few days off, and come back to it. By thinking about it as a break we prevent ourselves from getting locked into a set schedule, side-stepping some of the intimidating overhead and fear of stagnation, while, still remembering to come back to our skill every now and then.

Keep it short</h2>
We can only maintain focus for a few hours at a time at most. Many professional athlete’s have short, focussed training sessions of around 40 minutes focussing on one skill. They might do more than one session in a day, but one session at a time.

Practice deliberately</h2>
Deliberate practice is a bit of a buzzword. What it means is to avoid simply showing up and unconsciously do the actions of your target skill. Instead we want to be attentive, mindful, and focussed on developing specific chunks of our target knowledge. If I’m practicing archery I want to show up and work on having consistent shoulder tension for twenty minutes, then take a break and evaluate my form by shooting at the target and paying attention to where my inconsistencies are.
The other part of deliberate practice is that we must run towards our weaknesses. To build a full skill set we can’t just do the parts we’re good at, we have to locate our points of failure and strengthen them.

Pick the most minimal example you can, then do it</h2>
When reading a math paper, it’s good practice to find the simplest example of the principle being described and work through it to see how the machinery works. It’s also a good idea pretty much everywhere else.

Celebrate</h2>
We have reward circuits built into us! We are allowed to use them! Whenever we have a success, we celebrate to re-inforoce that success. Jump! Cheer! Douse yourself in gatagorade! Hug your friends! Go buy some pie! If we only celebrate on big milestones, at best our overall impression of learning becomes neutral labor, at worst it becomes tagged with all the misery of our set backs. We need to make sure that our successes are at least as rewarding as the efforts and setbacks are discouraging.

Pre-visualize</h2>
I hesitate to call this necessary or always applicable but sometimes sitting down and mapping out what you want can be exactly what we need. It can give us a north star to look to in times of uncertainty. Pre-visualizing success can make the moment things work feel familiar rather than panicky and unsure. It can smooth out decision making and make skill acquisition feel at hand rather than miles off.
Connect with pleasure</h2>
Learning feels good. There is a deep satisfaction in unlocking a new part of ourselves, in experiencing ourselves in a whole new way, whether that’s with new language, new knowledge, or new ways of moving our bodies. Every time we learn a new skill we become more of who we are; ee unlock more of the potential from our lives.
Take notes, after you’ve digested the information</h2>
Making our own reference material feels great and allows us to test how well we know our stuff. But, If we do it too early we might feel like we’re learning without actually committing anything to memory. We need to let the knowledge percolate, organize and be recalled once or twice before we start writing notes, otherwise we’re simply copying information down without thought. The other danger of making reference notes too early is we don’t have a good understanding of the material yet and can’t organize our thoughts in a way that will be useful to our future selves.
This doesn’t mean we can’t take notes during the learning process. We just need to be sure we’ve considered and practiced retrieving the material first. And, unless our learning notes are exceptionally well organized, we should probably come back to do a second pass to produce our actual reference material.
Notes and tips</h1>

Write your to-do list the night before, that way you have time to brace and prepare in our sleep</li>
make notes indexable and useable. Use headings, subheadings, accent colors, and even tables of contents to make it easy to find and retrieve the information you need when you need it.</li>
Leave lots of empty space in your notes so that you can annotate and correct anything you write down.</li>
use a mind palace to store ordered sequences</li>
use odd images full of vivid sensory details as mnemonic devices to remember and cluster concepts.</li>
If reading a document, know that the author is trying to guide us through a specific thought process, if we pay attention to the conventions they use to present something to us, and where else we’ve seen them used, it can help us find new associations that help us better understand the subject.</li>
Learn with other people, what clicks with one person won’t click with another, by discussing, even amongst newcomers everyone comes away with a more well rounded understanding.</li>
Sometimes after making progress for a while, we will feel like we plateued or got worse, this is actually a normal phase of learning and can occur when our brain is going through the process of reanalyzing and restructuring our knowledge.</li>
If you can turn learning into a game, do it. Play not only encourages exploration, but lowers our mental barriers to acquiring new information and rules.</li>
You are under no obligation to read the entirety of a textbook or article. Everything on earth is just reference material. Skip to the part that interests you right now, digest it, then leave the book behind until you need it again.</li> </ul>
proposed procedure</h1>

try it out: its difficult to know what people are talking about if you have no experience. Don’t try to do it well, just try to get a feel for it.</li>
research: remember to skip around the knowledge area to build a holistic picture and look for ways to relate the knowledge back to things we already know.</li>
take a break</li>
set goals and drills: once we know a little bit more about the domain we can start setting up small and achievabel practice goals and drills. For example, learning to make websites:

make a single static page with no styling</li>
make a single static page with styling</li>
add javascript interactions to some of the elements</li>
make a multipage website</li> </ol> </li>
deliberate practice

do project or drill</li>
evaluate</li>
take a break</li>
research</li>
repeat</li> </ol> </li> </ol>
example: taking up running</h1>
I bounced off running a couple times, but then I started playing tag with a friend and got competitive about it. I took up running to improve my stamina and better my odds. Day 1 I picked a trail near my home and ran it without any prior running research. I realized that my stamina was worse than I thought, but also found myself frustrated with how heavy my foot-falls felt and how much my body shook with each step.
The next day I watched some videos and read some articles about running focussed on fixing my heavy footfalls and jostling gait. I learned that the primary variable affecting the smoothness of my run is cadence (how many steps per minute) and that how heavy a footfall feels is primarily a factor of how far ahead of the center of gravity the foot contacts the ground. With these in mind on my next few runs I evaluated how my feet and body felt while trying out different cadences and postures until I found a way to run comfortably and stay acceptably light on my feet.
I then realized I still wasn’t satisfied with my endurance, after each run I was exhausted and I didn’t feel closer to being able to meet my distance goals even if each run was no longer horribly uncomfortable. I did a little more research and learned that the exhaustion I felt was likely a result of poor pacing. I started setting challenges for my runs like “run as slow as possible without walking” or “run twenty minutes without walking or stopping, slow down the run instead”. My goal shifted from improving my time to reducing exhaustion. Now, I’m working on alignment and technique, my goal has shifted to making my weight distribution neutral to forward heavy and I will walk long distances adjusting my torso and feet, looking for a stance that feels like it draws me forward.

liquid soap for icecast

2024-12-06T00:00:00+00:00

Liquid soap is a scripting language for programming and controlling live broadcasts.

concepts</h1>

classes of objects</h2>
Liquidsoap consists of four components

requests which are an abstraction of a file. They take in a uri (a url or file path) and resolve it to media and metadata.</li>
sources which provide media data, i.e audio from a file.</li>
filters these are functions that take in and output an audio source.</li>
outputs these are the endpoints that we send our audio data to, such as an icecast mountpoint.</li> </ol>
clocks</h2>
clocks are the secret 5th object, but are largely obscured from us except when liquidsoap’s automation cannot infer a clock on its own. In real time networks there cannot be a universal clock, each computer and potentially each process will be running at its own rate. To account for any discrepancy and maintain a simple model liquidsoap makes the rule that each source has its own clock.
fallibility</h2>
If a source is fallible that means that it can stop sending audio data, breaking the chain of audio data. We can fix this with a fallback filter that switches over to another generator if the primary generator fails. By using fallback we can make our source infallible, meaning that it will always be sending audio data. Outputs will error
how streaming works</h1>
snippets and examples</h1>
working with the shell</h2>
https://www.liquidsoap.info/doc-2.3.0/cookbook.html#unix-interface-dynamic-requests
speech synthesis</h2>
`say $(time)</code></pre>`
set metadata</h2>
annotate:</code></pre>sources</h2> single("path/to/file.mp3")</code></pre> creates a source that repeats the same audio forever playlist("path/to/file.m3u") playlist("~/Music/")</code></pre> creates a source that plays songs in sequence. It can take any file that’s just a newline separated list of uris but also more advanced playlist formats like pls or m3u. playlist has 3 modes: normal: plays in order</li> randomize: shuffles playlist and then plays in order</li> random: picks a random song after each track ends</li> </ol> By default once a playlist is created it doesn’t update itself if the file/directory it was generated from changes. The reload</code> argument allows us to update the playlist on file change with reload="watch"</code> or after a certain period of time or after every time it completes a round.The playlist’s reload method can also be called by another function. for remote sources we need to use input</code> input.<protocol>(<URI>)</code></pre>programming (the radio kind)</h2> play next</h3> by default source combinators are track sensitive meaning that they will wait for the currently playing track to end before switching to the next one. We can make them switch instantly if we use the keyword argument track_sensitive=false</code>. Note that some sources don’t have track data and so will never have an “end” for a switch to take place at. random([source1, source2])</code></pre> will randomly pick between the provided sources sequence([source1, source2, source3])</code></pre> will play one track from each source in order and then play from the final source. interrupt now</h3> fallback(track_sensitive=false, [primary, secondary, tertiary])</code></pre> will play whichever source is active and highest priority. If primary is normally off, and secondary is regular programming, you can override secondary by activating the primary source the track_sensitive</code> option lets us do instant fallback. If we don’t set it false it will wait for the track to finish before switching. If the track is infinite then it will never switch! outputting</h2> This is actually the last step. We create an output object with any log in information we need and pass it our programming source. output.file(%mp3, "out.mps", source)</code></pre>read more</h1> http://www.liquidsoap.info/book/book.pdf</a> language tour</a>

how to flask

2024-11-24T00:00:00+00:00

flask</h1>
flask is a framework used for building web apps. it uses the jinja template engine
It primarily operates via an `app</code> object.`
`flask is built on the WSGI spec, what this means is that the server hardware is running a WSGI server, that server receives an HTTP request, transforms it into a WSGI environ dict, calls a WSGI application (flask) with that environ dict, the application processes the dict and returns a WSGI response which the server translates to an HTTP response and sends it to the client.`
`what this means is that we never actually touch a raw request we simply set up responses for different cases our flask app might get.`
`Flask also makes use of the jinja template engine and the workzeug module to provide a bunch of handy functionality such as input sterilization.`
`We can connect our own database layer but flask doesn’t come with one. That said, there is a version of SQLAlchemy, a popular database abstraction layer, preconfigured to work with flask called Flask-SQLAlchemy</code>`

objects</h2> app</h3> the app object represents the WSGI application the server will call with a request dict. It holds all the configuration information and all the request handlers. request</h3> represents the request dict. Stores query string variables and cookies. Access query vars with request.args</code> and cookies with request.cookies</code>. Both are stored as dictionaries. It’s reccomended to use request.cookies.get("key")</code> to avoid keyerrors. Access request form data with request.form["field_name"]</code>. to access JSON data we use request.json["field_name"]</code> session</h3> Holds user specific data between requests. we can add and remove data from it. An example would be adding a username to the session on login. The session object is serialized into a cookie on the client, so you have to be conscious of size to avoid truncating it. The session cookie is encrypted with the secret key that you can configure in flask. g</h3> this is a proxy object for you to store stuff in that can then be acessed by any function in the app, it does not persist between instances. You can set a new member simply by doing g.foo = data</code>. blueprint</h3> a blueprint is essentially a middle layer between an app and some views. It allows you to group a bunch of related views together into one blueprint which can then be added to the app. as far as writing views for a blueprint is concerned it exposes an identical interface as the app object. to integrate a blueprint into the app use def create_app(): from . import blueprint_name #your blueprint is defined in blueprint_name.py app = Flask(__name__, instance_relative_config=True) app.register_blueprint(blueprint_name.bp) return app</code></pre> To initialize a blueprint in your blueprint_name.py</code> file: bp = Blueprint('blueprint_name', __name__, url_prefix='/url_prefix')</code></pre>application phases</h2> this is analogous to compile time and run time. In the set up phase we are defining our routing and logic etc. In the serving phase we the programmer do nothing. Our flask app should not be self modify and flask should error if we try to make it do so. set up is where we do our app configuration and define all our views etc, essentially building our app instance.</li> serving is our run time when the flask app object we created is receiving requests</li> </ol> set up</h3> we need to configure the app object with a couple things: the name of the file</li> a secret key for session data</li> a path to a db</li> </ul> app = Flask(__name__, instance_relative_config=True)</code> creates the Flask instance. __name__</code> is the name of the current Python module. The app needs to know where it’s located to set up some paths, and __name__</code> is a convenient way to tell it that. instance_relative_config=True</code> tells the app that configuration files are relative to the instance folder. The instance folder is located outside the app package and can hold local data that shouldn’t be committed to version control, such as configuration secrets and the database file. views</h2> these are either functions or classes bound to a url. See routing. directory structure</h2> The flask app crawls its local directory looking for templates and static files to include. a typical structure looks like: project_dir/ | +- app/ | | | +- templates/ | +- static/ | +- __init__.py | +- app.py | +- tests/ | +- venv/</code></pre>request handling</h2> routing</h3> by placing a decorator on a function we can bind a part of the app object’s request interface to that function as a request handler. we can include parameters in the route path using /<foo></code> then binding to a function that takes foo</code> as an arg. we can also bind post requests with a decorator instead of returning raw http we can return the result of a render_template('template.html', foo='bar', baz='bat')</code> call HTTP methods in routes</h3> specify what methods a route supports with @app.route('/', methods=['GET','POST'])</code>. Note that 'GET'</code> is the default and methods is always a list. We can specify the method in the function body with if request.method == 'POST':</code> We can also do @app.get('/')</code> and @app.post('/')</code> to have separate functions for common http methods. reading query strings</h3> Query strings are what comes after a ?</code> in a url, for example site.com/query/?foo=0&bar=something</code> we can then access these in flask via request.args</code>. Models with SQLAlchemy</h2> SQLAlchemy is a python abstraction layer on top of SQL, it allows us to interact with an SQL database only using python. SQLAlchemy’s interface is handled through a database</code> object. We initialize the database by defining model classes that represent the table structure and then calling db.create_all()</code> to make the tables in the actual sql database. We then interact with the database using the database.session()</code> onject Like with mysqlconnector we then query the database with database.session.execute(command)</code> followed by database.session.commit()</code> which guarantees all changes are made before moving on to the next piece of code. Models</h3> Models are essentially a way of representing data tables with object orientation, referred to as ORM (Object Relational Mapping). Sessions</h3> Sessions are how we interact with the database object. It represents a queue of commads we’ve sent and we can ensure they’re all executed using the commit()</code> method, which blocks until the last query is completed. JSON</h2> gets returned if we send back a data object authentication and verification</h2> this can be done with workzeug or hosting</h1> to run the app locally use flask --app foo run</code>. to host on the local network add --host 0.0.0.0</code> jinja</h1> the three types of placeholders are: {% statement %}</code></li> {{expression}}</code></li> {# comment #}</code> {{ foo.bar }}</code> and {{ foo['bar'] }}</code> are equivalent. you can escape using {%raw%} ... {%endraw%}</code> or {{ '{{' }}</code>.</li> </ul> The big power of templates is that it enables code reuse and parametric page generation. Meaning we can set up a template for the main page structure including our nav bar and footer and then load in different content for every page. We can also make a macro that represents a small component we can reuse multiple times a page or reuse in multiple pages across the site. We also have filters which are like fucntions. The prime functionality of jinja is template blocks. Each block has a scope and expressions cannot climb out of their local scope unless the block is declared with a scoped</code> modifier like {%block foo scoped%}</code>. We pass data to jinja via keyword arguments to flask’s render_template</code> function, which we can then access by name. render_template("test.html", data="foo")</code></pre> and then accessed by the keyword name {{data}}</code> Objects in the “standard flask context” are also accessible from within jinja, most importantly session</code>, request</code> and, g</code>. We can then key into object by for example doing {{session['username']}}</code>. include</h2> renders the entire included template import</h2> {% import "macros.html" as macros%}</code></pre> adds declarations into scope, useful for macros inheritance</h2> First we define a base template. Inside the template we define blocks for a child template to override. {% block foo %} default content {% endblock %}</code></pre> In our child template we inherit from another template via {% extends "foo.html" %}</code>. We then redefine the blocks to overwrite {% block foo %} new content {% endblock %}</code></pre> we can also keep the old default behaviour by calling \{\{super()\}\}</code> inside our new block. macros</h2> {% macro input(name, value='', type='text', size=20) -%} <input type="{{ type }}" name="{{ name }}" value="{{ value|e }}" size="{{ size }}"> {% endmacro %} <p>{{ input('username') }}</p> <p>{{ input('password', type='password') }}</p></code></pre>filters</h2> we can call filters a number of ways: {{var|filter1|filter2}} {{filter2(filter2(var))}} {% filter filtername%} content to be filtered {% endfilter %}</code></pre>iterating over lists</h2> {% for item in items %} <p>item</p> {% endfor %}</code></pre>MYSQL</h1> I WILL BE USING MARIADB SINCE THAT’S WHAT ARCH LIKES on arch you must start he server using systemctl start mysqld</code> before connecting to the server with the mariadb</code> command. By default mariadb stores its files in a default directory like usr/mysql/</code>. The root user will have the same log in as the root computer account. You can use mariadb as root by doing sudo mariadb</code> SQL is a relational database system. It uses tables where every row is a record and every column is a field. We can then set up relations between tables in a database. Meaning we link the rows of one table to the rows of another. SQL commands</h2> -- SQL syntax order is: SELECT _ FROM _ JOIN _ ON _ WHERE _ GROUP BY _ HAVING _ ORDER BY _ UNION</code></pre> sometimes you may need to select a database by running use db_name;</code> you can then select a different database later or quit the whole session to go back to having non selected. setting up a new user</h3> create user 'name'@localhost identified (with <policy>) by 'password'; grant <privileges> on <db> to 'name'@localhost (with grant);</code></pre> privileges are stuff like create</code>, alter</code>, drop</code>, insert</code>, update</code>, delete</code>. linking tables</h3> we use joins to link tables. The join returns a new table with records concatenated based on some foreign key, for example customer IDs from the customer table and customer IDs from the order table. select orders.order_id, customers.customer_name, orders.date from orders join customers on orders.customer_id = customers.customer_id;</code></pre> using left or right join returns all the records of the left or right table even if there is nothing to join it to. we can also union two tables or selects together using either union</code> or union all</code> to include duplicates. a field we can join on is referred to as a key. A primary key is a unique value to identify a certain record, something like customer_id</code> in the customer</code> table and a foreign key is something like the customer_id</code> field in the orders</code> table that we can use to link orders to customers. creating tables</h3> create table name ( column_name TYPE CONSTRAINT, column_name2 TYPE CONSTRAINT,.... );</code></pre> some examples of types are text</code>, integer</code>, date</code>. Some constraints are primary key</code>, auto_increment</code>, not null</code>. entering data</h3> We add data to a table using insert into table_name (column1, column2, ...) values (value1a, value2a, ...), (value1b, value2b, ...);</code></pre> where the column tuple indicates which fields the values are tied to, and each value tuple is a new record to be inserted. getting data</h3> The fundamental way to query data is with the select _ from table</code> command. We can select everything using select * from table</code> or we can do select field1, field2,... from table;</code> to only return the data from certain fields rather than the whole row. We can use select distinct name from employees;</code> to get all the unique names of employees. But what if we want to filter out whole rows using where</code>. For example select name from friends where name like 'j%';</code> to get all friends whose name starts with J. You can concatenate columns in your query by doing select lastname + ',' + firstname as fullname from friends;</code></pre>updating data</h3> we update the structure of a table using the ALTER</code> keyword. To update records we use the UPDATE</code> and SET</code> keyword filtered using WHERE</code>. ALTER</code> lets us add and remove columns to a table or rename them, for example: alter table customers add email text(50); alter table customers drop column email; alter table customers rename column f_name to full_name</code></pre> To update records do: uodate customers set lastname = "hapsburg", city = "berlin" where customerID = 1;</code></pre>deleting data</h3> we can delete a table by doing drop table table_name</code> we can also clear all the data from a table via truncate table table_name</code>. To remove specific records from a table use delete from table_name where column_name=value</code> creating procedures</h2> An unparametrized procedure: create procedure getCustomerIds as select id from customers go; exec getCustomerIds;</code></pre> a parametrized procedure create procedure getIdsByNameAndCity @name text, @city text as select id from customers where city = @city and name = @name go; exec getIdsByNameAndCity @city=seattle, @name = henry;</code></pre> you can set specific data to be returned using the output</code> keyword create procedure getIdsByNameAndCity @name text, @city text, @output_data output as select id from customers where city = @city and name = @name go; exec getIdsByNameAndCity @city=seattle, @name = henry;</code></pre>connecting to the server</h3> import mysql.connector mydb = mysql.connector.connect( host="localhost", user="yourusername", password="yourpassword" ) print(mydb) </code></pre>executing on the server</h3> To do stuff on the server we use an object called a cursor cursor = mydb.cursor()</code> then we execute sql with cursor.execute("SQL CODE")</code>. The data returned from the query will be stored in cursor</code> as an iterator, we use cursor.fetchall()</code> to see everything. If we modify the databse in anyway we then have to commit the change using connection.commit()</code>. Javascript http requests</h1> in order to build extra functionality into our website we may need to make our webpage do calculations that need execution on the server side, to accomplish that, we use javascript to send an http request to the server and display the response. We can use the fetch</code> function or aXMLHttpRequest</code> object. Fetch is newer but not yet featureful enough to deprecate the request object. note that refreshing a page in javascript is finicky so if you want changes to update the whole page rather than a specific element after the request is sent its best to send the request using a form submission, either via html with <form method="POST" action="url"></code> or by overriding the submit button in javascript if we want to enrypt the data client side first, for example. After encrypting the data we can then call form.submit()</code>. Note, that if using form.submit()</code> we need to make sure we’ve updated the form data or are using a hidden form with the encrypted data. XMLHttpRequest object</h2> the XMLHttpRequest</code> object represents the request across its full lifetime, first we build the request into the object, then we send it, then we read the response from the request object’s attributes. We can also read the request’s progress before it’s complete using a callback. steps of use: construct with xhr =new XMLHttpRequest()</code></li> initialize/configure with xhr.open(<"GET"/"POST">, <URL>, [optional: async, user, password])</code></li> set up callbacks for: xhr.onload = function</code> executes on completion of request</li> xhr.onerror = function</code> executes if request couldnt be made</li> xhr.onprogress = function(event)</code> executes periodically with an event object containing download progress information</li> </ul> </li> send the request xhr.send(<request body>)</code> (can be empty, like if we’re doing a get request)</li> callbacks execute</li> read response data from object attributes such as xhr.status</code> which holds an http status code such as 200</code> or 404</code>.</li> </ol> note in step 2 if we set async to false, execution will pause until the request response is received after we send it. sending data in a request</h3> We now know how to make a request, but how should we include data in that request? url</h4> We can use the url as a variable and simply request a url that the server then does a calculation on. For example we can make a request to site.com/math/sin/<number></code> and the server will respond with the sin of <number></code>. querystring</h4> site.com/math/addition?x=<m>&y=<n></code> request body</h4> When we send a request we can send it with a jason or form data body. xhr.send(JSON.stringify({field1: "foo", field2: "bar"})) xhr.send(new FormData(document.querySelector("#form")))</code></pre>readystate</h3> the xhr.readystate</code> attribute represents the request state. state code</th> meaning</th></tr></thead> 0</td> initial state, object just was just created</td></tr> 1</td> request has been initialized/configured by calling xhr.open()</code></td></tr> 2</td> response headers received</td></tr> 3</td> response is loading (set every time we receive a data packet)</td></tr> 4</td> request complete, response fully loaded</td></tr> we can then set up a callback for xhr.onreadystatechange = function</code> that handles each state.</td> </td></tr> </tbody></table> response type</h3> we can request the server send its response in a specific format via xhr.respoonseType</code>, our options are: "text"</code> (this is the default )</li> "arraybuffer"</code> (binary data)</li> "blob"</code></li> "document"</code> (xml,html, etc)</li> "json"</code></li> </ul> bootstrap</h1> Bootstrap is premade css and js that implements a whole bunch of common design patterns. By including it in your html document you can rapidly flesh out and prototype a useable website without having to build your buttons, forms, etc from scratch. The base document with bootstrap should look like: <!doctype html> <head> <meta name="viewport" content="width=device-width, initial-scale=1"> <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" crossorigin="anonymous"> </head> <body> {{content}} <script src="https://cdn.jsdelivr.net/npm/@popperjs/core@2.11.8/dist/umd/popper.min.js" crossorigin="anonymous"></script> <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.min.js" crossorigin="anonymous"></script> </body></code></pre> to style elements bootstrap coms with a bunch of prebuilt classes, for example to make a button look like a button we might do <button type="button" class="btn btn-primary">click here!</button></code> Ideally we don’t need to write any css we just compose bootstrap classes for example <div class="jumbotron text-center">centered large text</div></code>. We can also cheat a little bit and use prebuilt themes from other people. All responsive webdesign really means is that everything is defined relative to the display dimensions so that its always legible. Mobile first means that it prioritizes and is developed for use on phones, with the larger displays largely derived from the mobile design. Layout classes</h2> At its core Bootstrap is a resonsive, mobile first framework. We use container classes that embed behavior and relations between content blocks. For example having a top bar above a column layout. containers</h3> .container</code></h4> is a fixed width container meaning it sticks to a set dimension. .container-fluid</code></h4> is full width meaning it expands to fill the space its given. the grid</h3> Bootstrap is built around a 12 column grid system. These columns can then be merged to make larger cells, they dont have to be evenly divided. to divide the grid we do <div class = "row"> <div class = "col-x"></div> <div class = "col-y"></div> <div class = "col-z"></div> </div></code></pre> where x</code>, y</code>, z</code> add up to 12. Note that we can have up to 12 columns and arbitrary rows. widgets</h2> icons</h3> theres a lot of icons and glyphs built into bootstrap. most of them are accessible via glyphicon-<glyph></code> applied to an empty span or other object. dropdowns</h3> Bootstrap also has dropdowns and stuff prebuilt using a combination of js functions and css. <div class="dropdown"> <button class="btn btn-primary dropdown-toggle" type="button" data-toggle="dropdown">Dropdown Example <span class="caret"></span></button> <ul class="dropdown-menu"> <li><a href="#">HTML</a></li> <li><a href="#">CSS</a></li> <li><a href="#">JavaScript</a></li> </ul> </div></code></pre>buttons</h3> We have .btn</code> as our basic and stuff like .btn-success</code> and btn-danger</code> as extensions. We can modify the button with btn-block</code> and active</code> / disabled</code> and btn-lg/sm/xs</code>. tables</h3> HTML already comes with markup for tables but bootstrap comes with extra classes to define table styles and behavior. .table</code> is the base class and some of the extensions are table-striped</code> and table-compact</code>. The tables also have highlighting classes like .success</code>, .danger</code> etc. forms</h3> There’s not really much to say in terms of styling but we have classes that control layout form-inline</code> and vertical is the default. We can build nicer inputs using input groups. <form class="form-inline"> <div class = "input-group"> <span class = "input-group-addon"><i class = "glyphicon glyphicon-user"></i></span> <input id = "user" class = "form-control" name="user"> </div> </form></code></pre>styling classes</h2> Bootstrap implements all of htmls semantic markup as well as extending it with additional classes largely geared towards alerting the user and communicating status alerts. some notable examples are html</th> description</th></tr></thead> </code></td> highlights cenclosed text</td></tr> <kbd></code></td> highlights and uses monowidth fonts, meant to be used to diplay hotkeys</td></tr> <code></code></td> monowidth font with background and color change, used for code snippets</td></tr> <blockquote></code></td> blockquote</td></tr> <pre></code></td> verbatim environment</td></tr> .text-muted</code></td> greyed out text</td></tr> .text-success</code></td> green text for success messages</td></tr> .text-danger</code></td> red text for errors etc</td></tr> .bg-danger</code></td> red background</td></tr> </tbody></table> js tools</h2> python knowledge</h1> decorators</h2> Decorators are synctactic sugar on wrapper functions. If you write a function wrap:func -> func</code> that takes a function as an argument and returns a function that does some stuff, then calls the argument function, then does some stuff, then it can be used as a decorator. def wrap(f): def wrapped(*args): print("preamble") f(*args) print("postamble") return "wrapped" return wrapped @wrap def foo(bar): print(bar) return "foo" foo("amble") #prints: preamble // amble // postamble as expected #returns "wrapped"</code></pre>mysqlconnector</h2> all you really need to know is: connection = mysql.connector.connect(user="", password="", host = "") cursor=connection.cursor() cursor.execute("sql query") cursor.commit() data = cursor.fetchall() connection.close()</code></pre> a constraints lead approach to coding 2024-11-23T00:00:00+00:00 I stumbled across the phrases environmental dynamics and Constraint Lead Approach earlier this week in the context of teaching grappling and self defense skills via play. The idea seemed interesting and so after reading up on it I want to consider what it would mean to adapt the same philosophy to teaching non-motor skills like programming. What is Environmental Dynamics / Constraints Lead Approach</h1> CLA is a pedagogical philosophy that seems to exist almost entirely in the realm of athletic coaching. The essential idea is that rather than lecturing students about how they should move their body or observing their play and providing verbal feedback and instruction, a coach should engineer or constrain the “environment” of a player to encourage exploration and learning. In this article</a> we’re given the example of, instead of explaining to baseball players how to position their bodies, or where to hit the ball, put a wall in front of them that they must hit the ball over. The athletes body then enters an exploratory space in this newly constrained environment and automatically learns how to hit the ball so it clears the obstacle. In short: we need to de-emphasize procedural education and create opportunities for experiential learning. What could we apply this to in coding education?</h1> Many newcomers to the world of programming get studk in a local minima where, having overcome the initial frustration of learning to interact with a new computer system, will only engage with their limited knowledge area in order to achieve their goals. An example I see in many classes is students avoiding the effort of learning how to use loops in favor of repeating the same few instructions as many times as they need. As their teacher I can instruct them as to how loops work and even demonstrate their usefulness, but if the challenge I give them accepts any program that ends in the desired state most won’t bother shifting their approach. But, what if I gave them a code budget that made over redundant solutions impossible? Some possible constraints</h2> limited lines/characters/blocks</li> limited nesting (you can only have 1 layer of ifs)</li> remove a piece of syntax (solve this without using explicit conditionals)</li> solutions must take less than x milliseconds</li> </ul> A wrench in the works</h1> the CLA methodology assumes that being able to explore the solutionspace is automatic. In the world of sports you don’t need to look up how to move your legs, you just move them, and adjust their movement without conscious effort. Disciplines that have very little to do with motor skills usually don’t have that same ability. For example if I don’t know Rust and am told to make a hello world program I’m not very likely to guess my way to fn main(){ println!("hello, world"); }</code></pre> in anything close to an efficient timeline. But, if I’m already fluent in Rust, in terms of having a strong grasp of the syntax, keywords, and standard library, I can then learn how to apply that language in the most efficient manner. At the moment this isn’t a fully fleshed out thought but I think it could be interesting. Perhaps best paired with a web tool that lets an educator push puzzles and restrictions to students’ IDEs to externalize the constraint and reduce verbal explanation time. We're back! 2024-11-02T00:00:00+00:00 Hello! Hello! You might have noticed this site didn’t update for almost a year, that’s because I lost the entire Zola directory and it wasn’t backed up in a non-compiled state anywhere. Thanks to BeautifulSoup I’ve just finished decompiling all the pages back to markdown and I’ve recreated the site in Zola too. You might notice things look a little different –I’m using a newer version of the same theme as before, and the decompilation may have left artifacts which hopefully I can solve as they come up. but for now here’s a quick little list of some stuff I’ve done: got way better at archery</li> taught some kids scratch and python</li> built a lambda calculus compiler study in python</li> built a compiler from a sort of Logo-like language to python for Edison Robots</li> built out a nicer demo page for the beat maker</li> a static site generator built in bash (I think this is before the site was lost, but I never published the post about it)</li> I made large scale collography project</li> I made some metal hairpins</li> played a lot of petanque</li> watched all of evangelion and the reboot</li> </ul> peglib quick ref 2024-01-18T00:00:00+00:00 these are some quick notes for my own reference of the peglib</a> readme PEG uses both /</code> and |</code></li> A/B</code> indicates a prioritized choice, meaning A</code> takes precedence over B</code></li> |</code> is only used as a delimiter between terminal character strings</li> "</code> , '</code> , ``` are used to encase literals</li> the ?</code> , *</code> , +</code> operators exist and consume maximally</li> .</code> is a wild card</li> character classes are denoted by []</code></li> &</code> , !</code> are syntactic predicates, &A</code> consumes a character if pattern A</code> is matchable, !A</code> consumes if pattern A</code> isn’t matchable.</li> ()</code> can be used as embedded options. i.e (A/B)C</code> matches A C</code> and B C</code></li> <></code> is used to denote token boundaries, for example if you want to use multiple regexp tokens.</li> </ul> using the library</h1> there is a parser type that takes in a grammar string for its constructor R"(...)"</code> every rule consists of a line of the form foo <- bar</code> then for every variable in the grammar you can set up a lambda // variable <- A \ B parser["variable"]=[](const SemanticValues& vs){ switch (vs.choice()){ case 0: // the first match, A break; default: // B break; } };</code></pre>you can set up an error handler with</h2> parser.set_logger([](size_t line, size_t col, const string& msg, const string& rule)){...}</code></pre> it will then be called when parsing fails. You can set a specific error message by adding {error_msg "foo"}</code> after a rule. error messages have the %t</code> and %c</code> placeholders for tokens and characters that the parser fails on. to make an ast</h2> use parser.enable_ast(); shared_ptr<peg::Ast> ast; parser.parse(text, ast);</code></pre> There is also a ast_to_s(ast)</code> method. By default the ast includes every variable the parser goes through in generating the provided source code. To make the tree more minimal we can use parser.optimize_ast(ast)</code> and we can flag certain variable in our grammar not to be optimized out using a {no_ast_opt}</code> flag. using the AST</h2> each ast node has the following members: const std::string path; const size_t line = 1; const size_t column = 1; const std::string name; size_t position; size_t length; const size_t choice_count; const size_t choice; const std::string original_name; const size_t original_choice_count; const size_t original_choice; const unsigned int tag; const unsigned int original_tag; const bool is_token; const std::string_view token; std::vector<std::shared_ptr<AstBase<Annotation>>> nodes; std::weak_ptr<AstBase<Annotation>> parent; std::string token_to_string() const { assert(is_token); return std::string(token); } template <typename T> T token_to_number() const { return token_to_number_<T>(token); }</code></pre> Using Dyalog APL outside of RIDE 2023-12-04T00:00:00+00:00 I decided I was going to participate in this year’s advent of code, and I decided I wanted to do it with APL. Now I already have Dyalog RIDE installed but I don’t want to create a new workspace for every problem so instead decided I would take advantage of the dyalogScript feature to write small executables in order to solve each problem. Now, VScode does have language support extensions for APL, including a language server client. However, I ran into some problems getting the language server running so instead I decided it would be easier to download an APL keyboard and run each executable from the command line. install the keyboard</h1> Go here</a> to download the keyboard. (for macos click the flag associated with your keyboard ie american layout) then go here</a> to view the layout. Press alt</code> to use the apl unicode keybinds. a basic example</h1> #!/usr/local/bin/dyalogscript name←⎕ ⎕←∊'hello ' name</code></pre>what to know about shell scripts</h1> ⎕←val</code> outputs to stdout</li> ⍞←val</code> outputs to stderr</li> val←⎕</code> evaluates stdin as apl code, thus strings must be ‘quoted’ or they will be used as names</li> val←⍞</code> pulls from stdin as a string</li> </ul> As far as I can tell, you cannot give a dyalogscript arguments like you would another script. However, you can pipe them in and your first read of stdin will receive whatever was piped in. If you try to read an argument this way it will simply ignore it and wait for user input. if we really want to we can always use a bash wrapper #!/usr/local/bin/bash echo $@ | ./foo.apl</code></pre> There might be a system command to get something like argv but I looked over the release notes and language reference and didn’t notice it. an extended beatmaker 2023-10-31T00:00:00+00:00 the beatmaker</h1> ,</code> light beat</li> .</code> heavy beat</li> :</code> cha-cha beat</li> ?</code> rest</li> *comment*</code></li> variable_name=beats;</code> for example foo=,:,:..,:</code></li> [variable_name]</code> to reference it in a beat</li> </ul>

Skylos

RSS has been added to the blog!!

Introductory Concepts of Cyber-security

Items of known dimension

Batteries</h1> AA:</p>

Paper items</h1>

USA common photo sizes</h2> 4“ by 4“</li> 4“ by 6“ (common post card size also)</li> 5“ by 7“</li>

Other</h1> soda cans 12.2cm (4.8“) tall</li> 6.62cm (2.6“) diameter</li> </ul> </li> smartphones: see this list from dimensions.com</a></li> </ul>

looking for an open source inventory management system

The problem:</h1> I am moving and need a way to track all my stuff. I also want to help a friend with a garage shop track her tools etc. And want to assemble event kits and track whats in them if I need to.</p>

snipeIT</h1> Seems beloved by its users, but is focussed on IT assets specifically, which could be made to work to my ends, but is probably not worth the hassle.</p>

Librebooking</h1> The idea seems cool, I like its dedication to open source. It seems a little rough around the edges and focussed more on the being able to reserve time part of things than the item tracking part of things than I’d like.</p>

highlights</h1>

shelf.nu</h2> It has a free tier cloud service that lets you dive right in and has decent functionality out the gate that works well for physical assets.</p>

frappe</h2> The fact that the asset management is part of a larger erp suite means that it has the potential to be an incredibly powerful tool if you centralize all the information in one spot. But there’s no free tier and the learning curve is kind of intense for a use case as small as mine.</p>

konbase</h2> really excited by the project scope, just don’t want to use its tech stack.</p>

ralph</h2> really excited by the fact it has a deb package and systemd service, unfortunately its scope doesnt seem very aligned with mine.</p>

Further Reading</h1> https://linoxide.com/best-open-source-library-management-software/</a> https://community.aam-us.org/discussion/recommendations-for-a-home-library-system-or-app</a></p>

Recreating Orbits in APL

notes from the mountain side

writing code to work with your meshtastic node

Overview</h1> meshtastic supports

hosting</h1>

MAKE YOUR OWN WEBSITE!

tutorial</h1> see my first post</a> for a quick explanation of how to use Zola, the static site generator,</a> to create a website.</p>

how to use twilio for automated texting

Flow Charts</h1> Twilio supports a flowchart automation system that allows you to build complex sms response systems, including making http requests to set up appointments etc.</p>

Get Violent.

postgresql on arch brief note

sms and mms from the computer

Summary of three shorthand systems

Teeline</h1> First, we have Teeline which is designed for easy adoption by virtue of using simplified letterforms to gain speed rather than phonetic spelling. Though it does introduce its own family of abbreviations. </p>

A foray into woodcut printing

Keeping your soul alive

take control</h1> Be loud, take up space, modify your environment, anything to prove you are real.</p>

listen to the mountain goats</h1> It’s a good band and John Darnielle is a good song writer.</p>

how to learn stuff

Where I got this from</h1> This post is primarily a way for me to summarize and consolidate what I’ve learned from Barbara Oakley’s “Learning How to Learn”. I also incorporate advice I’ve gotten from professors, from personal reading, and experience.</p>

what to do and why</h1>

Keep it short</h2> We can only maintain focus for a few hours at a time at most. Many professional athlete’s have short, focussed training sessions of around 40 minutes focussing on one skill. They might do more than one session in a day, but one session at a time.</p>

Pick the most minimal example you can, then do it</h2> When reading a math paper, it’s good practice to find the simplest example of the principle being described and work through it to see how the machinery works. It’s also a good idea pretty much everywhere else.</p>

liquid soap for icecast

concepts</h1>

classes of objects</h2> Liquidsoap consists of four components</p>

how streaming works</h1>

snippets and examples</h1>

working with the shell</h2> https://www.liquidsoap.info/doc-2.3.0/cookbook.html#unix-interface-dynamic-requests</p>

programming (the radio kind)</h2>

outputting</h2> This is actually the last step. We create an output object with any log in information we need and pass it our programming source.</p> output.file(%mp3, "out.mps", source)</span></span></code></pre>read more</h1> http://www.liquidsoap.info/book/book.pdf</a> language tour</a></p>

read more</h1> http://www.liquidsoap.info/book/book.pdf</a> language tour</a></p>

useful css details

variables/custom properties</h1>

box model</h1> The three display types:</p> block: starts on a new line and width and height properties are respected</li> inline: height and width properties ignored</li> flex: stretches to fill the space</li> grid: defines a set of columns and rows that it’s children will stick to</li> </ol>

how to flask

app</h3> the app object represents the WSGI application the server will call with a request dict. It holds all the configuration information and all the request handlers.</p>

g</h3> this is a proxy object for you to store stuff in that can then be acessed by any function in the app, it does not persist between instances. You can set a new member simply by doing g.foo = data</code>.</p>

Other</h1>

soda cans

12.2cm (4.8“) tall</li>
6.62cm (2.6“) diameter</li> </ul> </li>
smartphones: see this list from dimensions.com</a></li> </ul>

The problem:</h1>
I am moving and need a way to track all my stuff. I also want to help a friend with a garage shop track her tools etc. And want to assemble event kits and track whats in them if I need to.</p>

snipeIT</h1>
Seems beloved by its users, but is focussed on IT assets specifically, which could be made to work to my ends, but is probably not worth the hassle.</p>

Librebooking</h1>
The idea seems cool, I like its dedication to open source. It seems a little rough around the edges and focussed more on the being able to reserve time part of things than the item tracking part of things than I’d like.</p>

shelf.nu</h2>
It has a free tier cloud service that lets you dive right in and has decent functionality out the gate that works well for physical assets.</p>

frappe</h2>
The fact that the asset management is part of a larger erp suite means that it has the potential to be an incredibly powerful tool if you centralize all the information in one spot. But there’s no free tier and the learning curve is kind of intense for a use case as small as mine.</p>

konbase</h2>
really excited by the project scope, just don’t want to use its tech stack.</p>

ralph</h2>
really excited by the fact it has a deb package and systemd service, unfortunately its scope doesnt seem very aligned with mine.</p>

Further Reading</h1>
https://linoxide.com/best-open-source-library-management-software/</a> https://community.aam-us.org/discussion/recommendations-for-a-home-library-system-or-app</a></p>

Overview</h1>
meshtastic supports

tutorial</h1>
see my first post</a> for a quick explanation of how to use Zola, the static site generator,</a> to create a website.</p>

Flow Charts</h1>
Twilio supports a flowchart automation system that allows you to build complex sms response systems, including making http requests to set up appointments etc.</p>

Teeline</h1>
First, we have Teeline which is designed for easy adoption by virtue of using simplified letterforms to gain speed rather than phonetic spelling. Though it does introduce its own family of abbreviations. </p>

take control</h1>
Be loud, take up space, modify your environment, anything to prove you are real.</p>

listen to the mountain goats</h1>
It’s a good band and John Darnielle is a good song writer.</p>

Where I got this from</h1>
This post is primarily a way for me to summarize and consolidate what I’ve learned from Barbara Oakley’s “Learning How to Learn”. I also incorporate advice I’ve gotten from professors, from personal reading, and experience.</p>

Keep it short</h2>
We can only maintain focus for a few hours at a time at most. Many professional athlete’s have short, focussed training sessions of around 40 minutes focussing on one skill. They might do more than one session in a day, but one session at a time.</p>

Pick the most minimal example you can, then do it</h2>
When reading a math paper, it’s good practice to find the simplest example of the principle being described and work through it to see how the machinery works. It’s also a good idea pretty much everywhere else.</p>

working with the shell</h2>
https://www.liquidsoap.info/doc-2.3.0/cookbook.html#unix-interface-dynamic-requests</p>

`outputting</h2> This is actually the last step. We create an output object with any log in information we need and pass it our programming source.</p> output.file(%mp3, "out.mps", source)</span></span></code></pre>read more</h1> http://www.liquidsoap.info/book/book.pdf</a> language tour</a></p>`

read more</h1>
http://www.liquidsoap.info/book/book.pdf</a> language tour</a></p>

box model</h1>
The three display types:</p>

block: starts on a new line and width and height properties are respected</li>
inline: height and width properties ignored</li>
flex: stretches to fill the space</li>
grid: defines a set of columns and rows that it’s children will stick to</li> </ol>

app</h3>
the app object represents the WSGI application the server will call with a request dict. It holds all the configuration information and all the request handlers.</p>

g</h3>
this is a proxy object for you to store stuff in that can then be acessed by any function in the app, it does not persist between instances. You can set a new member simply by doing `g.foo = data</code>.</p>`