A lot of parents at our school signed a “wait until 8” pledge to wait until 8th grade before getting them smartphones. This way there will be less social pressure from their friends to be connected. My assumption is that without a smartphone they won’t use social media.
Same, and most of it was wasted time. But at least it didn't follow me to school, or bed, or well everywhere.
I'm not sure completely shielding your child from screens is the best approach. I'll be attempting to have a visible space in the house where a laptop or tablet can be used. But they stay there.
Xcode has this functionality. You can attach a system sound to a breakpoint. I used it exactly once when I was trying to determine if two events always happened in the same order and were always equally spaced in time. It worked well but drives you sort of mad after a while.
One interesting way of using this I've heard of; is attaching it to a `-[UIViewController dealloc]`, and being able to "hear" (or rather notice the lack of sound) retain cycles this way.
Xcode has all sorts of cool stuff you can do with breakpoints, one I used more often than sound is logging a value on a breakpoint and continuing execution.
Something I read recently that really hit home is: ”set a direction, not a goal and train yourself to embrace failure as a learning opportunity”. When you set a goal you’re setting yourself up for disappointment if you don’t reach the goal. If you set a direction you’re still improving but you’re freed up to enjoy the process not the result.
If I need to stop in the middle of something, I’ll often write directly in the source code, at the point where I stopped, exactly what I was working on and what to do next. I don’t comment out these instructions to my future self so when I sit down next, the project won’t even compile.
This is the way. The only way I can stop coding and stay comfortable when it’s getting late, especially if it’s something even mildly interesting, is to do a borderline incoherent mind dump and break the linter/formatter. Just all my thoughts, what I was working on, other places I may need to change code. I usually end up closing the laptop before I describe the why, but the act of writing it all down usually makes that come back before I’ve finished reading the first few words the next time I revisit it. I’ve found this remarkably effective to the point I often just do a mind dump the moment I feel tired at all, and end up in a better place than if I kept pushing.
Even easier with C-like languages: a bunch of blank lines above and below something like `xxxxxxxxx;` at the point I planned to continue working. Instant compile fail if I try to run and also very obvious on any "git diff".
I don’t usually leave notes, I just leave the last thing I looked at in whatever arbitrary failure state it was in, unsaved, with whatever undo history I stopped at. If the errors aren’t immediately obvious, a couple cmd-Zs is usually all it takes to jog my memory and at least start retracing my steps
I’m not who you’re replying to, but I hope my input will be helpful.
I just use Jetbrains IDEs on projects with the IdeaVim plugin (integrates so well with the IDE, it’s pretty much my only must-have plugin for any software, beyond uBlock Origin), and Vim for external files (scripts, etc., or when I want to use a specific plug-in for editing).
By default IntelliJ (PyCharm, GoLand. any Jetbrains IDE…) has a pretty large undo history, and that can be extended to however long you like. The real killer, however, is the extended local history for the file, which is arbitrarily (or at least seems to be) long. Combine that with the wonderful built-in git history (which can be a separate pane/window!), and you’ll never worry about changes you’ve made being lost, or overwriting other history, no matter how overzealous you were with said changes.
I find IDEA’s built-in tools so useful I barely ever even think of using git stash or git shelve anymore (or directly calling ~30% of git commands for that matter), and those are commands for which I still have 20+ aliases for in my .bashrc.
Intellij's local history saved my ass a couple of times.
Its git features are also quite comfortable. Very nice diff, I like very much the "Show history for Selection", live git annotate (with GitToolbox plugin). I don't often do rebase, but when I do the interactive rebase is also very helpful.
Closing my laptop and leaving it on a charger. Wish I had a better answer. I use VSCode and it does restore undo history on relaunch for the most part, but I can’t remember if I configured it for that, and I definitely don’t trust or rely on it. I know it definitely doesn’t work if I accidentally invoke “reload”.
I also write in the code what I was doing so the code doesn’t compile. My only issue is that I don’t trust my computer, for me, if it’s not pushed in Git then it can disappear at any moment. If the work is not too important and I could easily re-create it from scratch the next day then I’ll leave it in my local Git. But if it’s important then I also want to push it.
The failures I've experienced in 20 years of spending ~8 hours a day with one:
- SSD failure within moments of getting started for the day
- backlight failure
- mouse/keyboard failure
- human failure (spilling coffee on the computer)
Each time, I was out of commission until I got a replacement or the computer repaired and someone else had to pick up my work. If your computer becomes a brick, it doesn't really matter what you thought you wanted to do next.
I've had all these plus PSU failure, network adapter failure, OS post-update self-destruction and more.
I push code a couple of times a day. If something goes horribly wrong I just pick up another computer, pull the code, and continue working while I wait for a repair/part for the main computer (or for an OS to reinstall).
If your computer becomes a brick, just use a different computer.
That assumes you have another computer that isn't a brick. I have 6 other computers within this house, yet only one other one (my wife's) is currently functioning.
Yeah, true, I'm assuming most people here have old machines that still work. It's good to have one, if you don't!
My secondary is a 10-year old laptop which gets regularly used while sitting in bed in the morning, occasionally for actual work. The other backup is an old desktop I donated to my wife a few years ago, containing an unplugged SSD which is exactly as it was when I last used it. Both will still handle most of what I need, just a bit slowly.
Either you have been extremely unlucky, or a good time investment for you would be to fix a few of the non-working ones. That's likely a better use of your time than wondering how to leave notes to your future self.
Personally, I very rarely push commits unless I’m about to open a PR.
A coworker fell off a ladder and broke both his arms. We had to look at his commits to figure out what he had gotten done. It was worthless. Absolute trash. His finished code was always top notch, but his WIP code … trash.
It was easier to ignore it and start from first principles than to try and pick up where he left off.
If your philosophy is to do a PR at least every few days then the negative impact of this was likely negligible, especially comparing to have a fellow dev being out with having broken arms for a few months.
If you do PRs every few weeks then that could be a bigger issue. But then this should be a lesson to just not do that. Merge small steps often. It has tons of advantages.
Draft PR's are nice on these branches to get a quick visual of the diff.
I self-review my draft PR's and catch all kinds of weird formatting, messy or missing comments, and general clunkiness before imposing it on others to review.
This works well near the end of the day or before a weekend too where you spend a few minutes dropping in a brain dump of context near the code you're working on so you can pick it up the next day and also avoid having to actively think about forgetting an important detail. This helps you enjoy your time away. A double win.
Install the extension and point it to the neovim binary, lastly set the affinity for the extension (to make it fast).
The extension description documents some of the downsides, obviously vscode wasn't purpose build as a neovim frontend and some extensions or settings can not work (potentially they don't even make any sense), the documentation points out that your current init file may cause problems.
The alternative is the "regular" vim extension, which is more limited in functionality (but it even emulates common extension, like commentary) but potentially easier to set up.
But in the end you can get a "real" vim together with all the tooling (debugger, autocomplete, syntax, etc.) vscode extensions provide, which I think is very neat.
There’s a lot of multitasking with kids which I don’t think is healthy for the mind. Also I never have quiet moments to reflect which is when I make connections, mentally piece things together etc.
I had something similar happen to me a few years back. Someone using my photo and profile from my personal site and uploaded it to upwork to get contract work. I found out b/c someone hired them for a contract (thinking they were me) and got suspicious. The employer found my real email on my site and contacted me. Not sure what I can do to prevent it. I put a warning on my site saying to look out for impersonators.
High happiness and high unhappiness is how I would describe parenthood. On the one side your whole life is a chore and feels like a grind. On the other hand your kids give bring you so much happiness you seems to smile/laugh more often.
They share a lot of similarities. Both make it hard to do unsafe things, both have functional influences, both have modern features like closures, optionals etc. I'd say the biggest philosophical difference between the two is that Swift leans more toward developer ergonomics while rust is geared toward system level programming (ie tighter control over memory etc).
I also think there is a precision aspect to woodworking which is similar to writing code. I like to take the time to make my cuts exact, make sure things line up properly etc.
