• 1 Post
  • 146 Comments
Joined 2 years ago
Cake day: December 31st, 2023
  • Lightfire228@pawb.socialtocats@lemmy.world•STOP EATING THE GODDAMN PLANT
    2·
    8 days ago

    Find a bitter agent spray at the pet store, like bitter apple, and spray it on the leaves of the plant

    They’ll eventually learn that the plants taste bad, and leave them alone (saved my Aloe from a very mouthy feline, as well as various fabrics from the golden retriever puppy)

    Alternatively, put lemon or citrus scented spray on the plants, but i found that less effective compared to the bitter spray

    You can also get them cat grass or silvervine sticks to chew on

  • Lightfire228@pawb.socialtocats@lemmy.world•Oh yes
    30·
    9 days ago
    • Hot stove tops after cooking
    • potentially poisonous things like onions
    • knives
    • “i need to set this down for a second and i don’t want the cats messing with it”
    • dirty dishes

    Not to say i just leave knives or food out, but I want to reduce the chances of them getting into something by making the counters unappealing to them (via the usual tricks of aluminum foil, sticky tape, precariously perched baking trays, or as a last resort, cat zappers (electrified mats))

  • Lightfire228@pawb.socialtocats@lemmy.world•An artist with his work
    6·
    14 days ago

    You can train them to use scratch posts, but it’s going to depend on the stubbornness of the individual cat. Also, they like tall, sturdy scratch posts, so those tiny ones at the grocery store usually won’t cut it (same reason they go for the couch, it’s tall and won’t fall over)

    Although, if you have or are planning on having cats, i suggest never buying anything leather. All of my stuff is cloth, which is more resistant to claws

  • Lightfire228@pawb.socialtoProgrammer Humor@programming.dev•The Six Stages of Code Grief
    6·
    19 days ago

    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

  • Lightfire228@pawb.socialtoProgrammer Humor@programming.dev•The Six Stages of Code Grief
    17·
    20 days ago
    • 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;
}
  • Lightfire228@pawb.socialtoProgrammer Humor@programming.dev•The Six Stages of Code Grief
    34·
    20 days ago

    • 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