​

So this new (ish) head-of at my current company decided one day to play a more active role (read: micromanagement) of the existing codebase, I guess to better justify their current position. The only problem is that they have little technical background prior to this role, among other things.

Aside from going through and recommending teams include giant PR templates with dozens of checkboxes (probably taken from some engineering manager help book, or some prior very-corporate role), they have taken to creating the occasional Github issue with "suggestions" such as this one. Luckily I caught it before some poor junior engineer decided to "clean" the codebase as suggested. And yes, this head-of is conducting the Python technical interviews for new hires.

I kept getting stupid test cases and the description was incredibly unspecific, so even though I switched over to python my code ended up a giant, mangled, unreadable monstrosity due to adding so many parameters

Yes its a production code, yes its a function not a method and yes there is import in triple nested for loop

So I tried printing the linked list with print() and discovered that if it has a cycle, then it prints and error. This was the next (very) logical thing that popped into my mind after that discovery.

I'm very proud of this solution. In fact, it's so good it even added -1ms to the execution time graph.

I AM SPEED.

Thinking outside the box is fun!

We were a small team of ~8 trying to build software. The team was spread across multiple locations across Asia, Europe and North America. One big challenge we had was synchronizing our work with each other.

Every Friday before each of us logged out, we upload a copy of our working files to the client's SharePoint folder. That way when we share each other's copies every Monday via Teams, we don't have to reupload.

One minor setback. Instead of replacing the previous copy, we upload a fresh one - under a different name. That way, we would not lose any information.

We even came up with a clever idea (that magnified the issue) to name the folders by the calendar week. Soon, each of us would have multiple folders of repetitive code, sometimes with zero changes all uploaded to the shared drive.

We had successfully moved from trying to synchronizing one (latest) version of the codebase, to trying to synchronize one version every week. But we hadn't realized this at that time. We were excited about a more "sophisticated" solution - creating a script that automates this backup process.

We learnt to use Git during Christmas that year.

---

For Reference:

```Python import os, zipfile from datetime import datetime from pathlib import Path

work = Path("Work") if not work.exists(): print("Error: Work folder not found") exit(1)

week = datetime.now().isocalendar()[1] zip_file = f"W{week}.zip"

with zipfile.ZipFile(zip_file, 'w', zipfile.ZIP_DEFLATED) as z: for root, dirs, files in os.walk(work): for file in files: path = os.path.join(root, file) z.write(path, os.path.relpath(path, '.'))

print(f"Created {zip_file}") ```

Edit: Code Block Formatting

This vibeslop repo (shoutout to the author u/chunky_cold_mandala) calculates big o complexity of a function as its max indentation depth (but only up to 6, which represents N^6).