Recently I vibe coded a couple of scripts invoked by cron to do the same thing for a few services running on a single node for me. Works beautifully.
147 karma · joined January 14, 2024
I find it interesting that I've thought about the exact social mechanics of making friends before as well - low stakes in person common context where you meet on a regular basis is key.
We're humans and no matter what you're pursuing, you'll hit a point where your brain will adjust to the new reality and things will start feeling mundane. This is called the hedonic treadmill.
To me, what has helped is developing hobbies and relationships outside of work. We're social animals and need connection with others to feel fulfilled. Personally, my own life feels way more fulfilled right now than when I was just working on interesting projects at work or on my startup (that went nowhere).
I personally think that even before LLMs, the cost of code wasn't necessarily the cost of typing out the characters in the right order, but having a human actually understand it to the extent that changes can be made. This continues to be true for the most part. You can vibe code your way into a lot of working code, but you'll inevitably hit a hairy bug or a real world context dependency that the LLM just cannot solve, and that is when you need a human to actually understand everything inside out and step in to fix the problem.
I quickly learned that I needed none of that crap. Now I usually just have one dev environment (my local machine) and one prod, usually a free cloudflare worker. DB is almost always a free tier postgres instance. Testing and prod deployment happens on git precommit and postcommit hooks instead of inside a CI pipeline. No docker is usually necessary as I just build typescript services which have native support on most platforms. DB migrations are run directly from my local machine when I need them to run, instead of having specialized config in a CI pipeline.
I don't think that's how it works. You can try to juice the rock as much as you want, but you can only choose any two of the three IMO. It's a structural constraint of making humans write code. If they end up creating code generating machines that can do this, good for them. But until then it'd serve everyone better if people just accepted reality.
How important is feeling "not screwed over" at the beginning of an employment important for you? Does it trump a great work environment and interesting things to work on? How sure are you that your subjective feelings during negotiations match how the employer actually is objectively?
It would seem intuitively obvious that there must be correlations between being screwed over in the beginning and then having a bad experience later on during the actual job as well. But I'm personally wary of blindly following intuitions in matters that relate to money.
Being able to just "walk away" from decidedly some of the highest paying jobs in the world (irrespective of the feeling of being low balled) is a privilege too.
Anyway, in my own personal experience, I was screwed over during the offer phase of a previous job, and the job was not great either - terrible wlb and politics, but I did learn a lot and became very efficient at my work. As a bonus I stopped caring about my work outside of being necessary for paying my bills, while still maintaining decently high quality output.
I had the opposite experience with my latest job - the recruiter was professional and empathetic, and I had a great offer experience. The job itself is great as well.
So yeah, maybe there are correlations, but I'm still just one data point and so I'm not keen to generalize yet.
So my choice is to live my life and enjoy it as much as I can.
When people call out the doom of SWE careers at the hands of AI, they seem to think that only SWE careers will be affected, which seems weirdly biased to me. If AI comes for our jobs, it'll come for everyone's jobs. And if that is the case, economics/capitalism as it exists today doesn't make any sense anymore.
To determine the output of the given `fizzbuzz` function for an input of 3, let's break down the code step by step:
1. *Function Definition*: ```javascript function fizzbuzz(n) { return (["Fizz","Buzz","FizzBuzz"])[ (n % 3 === 0) + (n % 5 === 0) ]; } ```
2. *Input*: - The input `n` is 3.
3. *Evaluate the Conditions*: - `n % 3 === 0`: This checks if `n` is divisible by 3. - For `n = 3`, `3 % 3 === 0` is `true`. - Therefore, `(n % 3 === 0)` evaluates to `1` (since `true` is treated as `1` in arithmetic operations). - `n % 5 === 0`: This checks if `n` is divisible by 5. - For `n = 3`, `3 % 5 === 0` is `false`. - Therefore, `(n % 5 === 0)` evaluates to `0` (since `false` is treated as `0` in arithmetic operations).
4. *Sum the Results*: - The expression `(n % 3 === 0) + (n % 5 === 0)` becomes `1 + 0`, which equals `1`.
5. *Array Indexing*: - The array `["Fizz", "Buzz", "FizzBuzz"]` is indexed by the result of the sum. - The index `1` corresponds to the second element of the array, which is `"Buzz"`.
6. *Return Value*: - The function returns `"Buzz"`.
Therefore, the output of the function `fizzbuzz(3)` is `"Buzz"`.
### Reflection and Error Checking - *Step-by-Step Verification*: - The conditions `n % 3 === 0` and `n % 5 === 0` are correctly evaluated. - The sum of the boolean results is correctly calculated. - The array indexing is correctly performed. - *Logical and Factual Accuracy*: - The logic and arithmetic operations are correct. - The array indexing is consistent with the conditions.
No errors were found in the reasoning or the final answer. The output of the function `fizzbuzz(3)` is indeed `"Buzz"`.
This has been a trend for my cohort of college graduates. Graduated right in time for a housing crisis, inflation, layoffs, etc. Can't help but feel at least a little bitter about folks who pulled the ladder up behind them.