You know, you could just ask what that means

s/org/li means replace org with li

I like solving puzzles, and I have a knack for programming specifically

Python

It’s an amazing scripting language, and my goto for writing automation scripts.

It’s the most lenient of the 3 with dynamic typing and managed memory. It’ll let you learn the basics of reading / writing / running code as well as basic control flow and logic

C is also great to learn, as it teaches you how computers work at a fundamental level, but it’s more stuff to learn up front, and can lead to some very difficult to fix bugs

Java is good as an “application” language. Being memory managed like Python, but statically typed like C. Static typing makes it easier to manage larger code bases

Lox

Once i have a solid implementation, I wanna morph it into a custom scripting language for generating diagrams (a la graphviz or mermaid js)

https://github.com/Lightfire228/lightweaver

I literally just wrote this a few hours ago (line 55)

Never make things more “impressive”

Make them more comprehensible

Reduce the cognitive load required to understand and reason about a piece of code. Honestly, the more you can express complicated ideas simply, the more impressive you are

I did this once

I was generating a large fake dataset that had to make sense in certain ways. I created a neat thing in C# where you could index a hashmap by the type of model it stored, and it would give you the collection storing that data.

This made obtaining resources for generation trivial

However, it made figuring out the order i needed to generate things an effing nightmare

Of note, a lot of these resource “Pools” depended on other resource Pools, and often times, adding a new Pool dependency to a generator meant more time fiddling with the Pool standup code

• if something feels too “heavy”, like it’s doing xml formatting, file manips, a db insert, and making coffee, all in a single class or function

Separate out those “concerns”, into their own object/interface, and pass them into the class / function at invocation (Dependency Injection)

• use “if guards” and early returns to bail from a function, instead of wrapping the func body with an if

public Value? Func(String arg) {
  if (arg.IsEmpty()) {
    return null;
  }
  
  if (this.Bar == null) {
    return null;
  }

  // ...
  return new Value();


  /// instead of

  if (!arg.IsEmpty) {
    if (this.Bar != null) {
      // ...
      return new Value();
    }
  }
return null;
}

• if it’s not in git / SVC, add it as is. Create a “refactor” branch, and liberally use commits

• Treat it like a decompilation

Figure out what something does, and rename it (with a stupidly verbose name, if you have to). Use the IDE refactor tools to rename all instances of that identifier

• Take a function, figure out what it does, and refactor it in a way that makes sense to you

• Use the editor’s diff mode to compare duplicate code, extract out anything different into a variable or callback, and combine the code into a function call. Vscode’s “select for compare” and “compare with selected” are useful for this

• Track what you’re doing / keep notes in something like Obsidian. You can use [[Wikilinks]] syntax to link between notes, which lets you build a graph structure using your notes as nodes

• be cognizant of “Side Effects”

For example, a function or property, or class might be invoked using Reflection, via a string literal (or even worse, a constructed string). And renaming it can cause a reflective invocation somewhere else random to fail

Or function or operator overloading/overiding doing something bizarre

Or two tightly coupled objects that mutate each other, and expect certain unstated invariants to be held (like, foo() can only be called once, or thingyA.len() must equal thingyB.len()

• write tests if you can, either using a testing framework or custom Python scripts

You can use these to more thoroughly compare behavior between the original and a refactor

Me like hot stuff

OwO

I did it once to pull out data from a spreadsheet into a database. Specifically, I needed "${DataType}${Month}" for each month for 3 different datatypes

Iirc, i used an sql pivot (or unpivot) in that query too

Usually, it’s situations like this where you’re parsing data from strings, and you need some glue code to interface between the input data, and the date library you’re using to actually resolve the datetime

Use SystemD timers, you animal

Think of it more like pre-canned build scripts. I can just write a script (DockerFile), which tells docker how to prepare the environment for my app. Usually, this is just pulling the pre-canned image for the app, maybe with some extra dependencies pulled in.

This builds an image (a non-running snapshot of your environment), which can be used to run a container (the actual running app)

Then, i can write a config file (docker-compose.yaml) which tells docker how to configure everything about how the container talks to the host.

• shared folders (volumes)
• other containers it needs to talk to
• network isolation and exposed ports

The benefit of this, is that I don’t have to configure the host in any way to build / host the app (other than installing docker). Just push the project files and docker files, and docker takes care of everything else

This makes for a more reliable and dependable deploy

You can even develop the app locally without having any of the devtools installed on the host

As well, this makes your app platform agnostic. As long as it has docker, you don’t need to touch your build scripts to deploy to a new host, regardless of OS

A second benefit is process isolation. Should your app rely on an insecure library, or should your app get compromised, you have a buffer between the compromised process and the host (like a light weight VM)

In my obsidian notes folder, i have

• 01 - Inbox
• 02 - Breadbox
• 03 - Data

.

• Inbox is for newly created notes
• Breadbox is for notes that i need to reference or otherwise want quick access to
• Data is for everything else

For file navigation, i use links and references within the notes themselves, which creates a network of linked files that is far far easier to navigate than folders

Everything else is sorta all over the place, but in general

• ~/Documents
  • dumping ground for important documents, folders are arbitrarily made as I go
• ~/Downloads
  • dumping grounds for downloaded things, generally important files are moved elsewhere
• ~/Code is where i put all of my personal projects and other junk related to programming

~/ is the user home directory

• C:\Users\Name for windows
• /home/name for linux

For pictures, i use a self hosted Immich instance

At least python has a decent runtime typing system

JS’s type system feels like what you’d get by giving a monkey access to unlimited cocaine and a computer

Sorry, I’m too Rust-pilled for this OOP nonsense

pub fn new() -> Self {
    Self::self().self.unwrap()
}

I can confirm, I’ve never used a non memory managed language, and the Rust borrow checker is a massive kick in the teeth

But, the more i consider it from the perspective of memory, and pointers, the borrow checker makes a lot of sense

Especially when storing references inside structs, and how mutability affects references

I actually figured out i could fix a re-mutable borrow error by performing the two mutable operations in separate for loops

Blue cheese is intentionally inoculated with mold. Specifically penicillium mold that is perfectly safe to eat.

If a cheese “naturally” develops mold, there’s a good chance it could be harmful, so don’t eat that

The SoC on the motherboard has a special EDL mode

This is kinda like the SoC’s pre-bootloader, which loads the bootloader and can be used to flash a new bootloader

EDL mode is locked behind vendor specific certs/keys, so it’s unaccessible to the device owner