Alice Averlong🏳️⚧️the button I want most in my Typing English career: a "yes that's misspelled, correct it to the first suggestion" button.
having to switch to a mouse to click on the spellchecking for every minor word is so tedious
maybe if you hit it again after it applies a correction, it goes to the 2nd most likely suggestion
I'd have to pair this with a spellchecker that understands my personal english dialect of Later IRC English, though. Standard spellcheckers don't understand how I capitalize and think I misspelled words all the time, just because I didn't capitalize them.
one thing I'd really love to have is a better way to do text input, like have a single program I type into that interfaces with everywhere I type English*.
right now it's a bunch of website textboxes, chat apps, text boxes... a unified customizable & hackable frontend for typing would be perfect.
* as opposed to programming/shell/commandline stuff, not other Human languages. The only other language I know enough to ever type in is Latin, and that's fairly limited. I'm sure I can figure out "cinaedus sum" myself
a few replies mentioned IMEs: maybe I could implement this as an IME, which'd let me tie it into my operating system's keyboard support in a nice way?
my other option is just having it be an always running textbox app, that appears when I hit a hotkey. But crucially when it appears, it queries the running program and figures out where the cursor is, so when I finish typing into the floating textbox, it can paste it back into there.
having it as as a browser extension would also get me 90% of the way there since that's my main place I type, but the remaining 10% would be a pain.
and browser extensions are a pain, too
I have been programming in a lot of environments for a long time and I have long since learned to identify when you're developing for an environment that hates you personally and is always going to be an uphill nightmare of security, updates breaking things, and 3rd parties you have to wait on to approve anything
and those environments are never fun to code in. you should be getting paid to code for them, or they will rapidly burn you out.
(if you're getting paid, they'll slowly burn you out)
this is why I don't usually do mobile or minecraft development.
I've done both before, but those environments hate you too much, so I'll stick to programming where it can be fun and enjoyable
I've done both before, but those environments hate you too much, so I'll stick to programming where it can be fun and enjoyable
maybe I should compose an official list: Foone's Symptoms of A Programming Environment That Hates You
1. Factors completely outside your control break the code periodically. This is anything that's an add-on, usually. The browsers changed something, the sites changed something, the game changed something... It's a project that can never be finished, can never be put away. It will just break on some random day because some people in a different organization with different goals changed it
this doesn't include the time my website broke because a subcontractor unexpected renamed columns in the database on a saturday. that's just a massive fuck-up
but any environment where shit changes periodically and have to change your code to fix it? easy burn out. you're not feeling like dealing with that app you wrote 3-20 years ago, but that doesn't matter, it suddenly needs attention or it will just stop working
2. third-party authorization before code can run.
The more steps there are between you writing code and that code actually running where it needs to be ran, the less enjoyable it can be for my specific style of fast-iteration-loop ADHD-fueled programming, sure, but the worst is delays where you need to wait on other people, people outside your organization.
The more steps there are between you writing code and that code actually running where it needs to be ran, the less enjoyable it can be for my specific style of fast-iteration-loop ADHD-fueled programming, sure, but the worst is delays where you need to wait on other people, people outside your organization.
nothing kills my motivation to fix problems and add features like knowing that even if I spend all day hacking on this, no one can see my changes until Wednesday (if I'm lucky. it might be Friday...)
this is why my personal projects are all on platforms like the web (where I run my own hosting, or use very simple free hosting) or scripts/binaries I can just throw up on github or my own site, and people can download and run them on their own machines.
3. Environments where you can't do it "the simple way". This is usually a security thing, but it can be other problems (licensing, approved software lists, etc).
Basically any scenario where there's a simple and easy way to solve your problem, but that can't be done, and a much more complicated solution must be done.
"security" itself isn't a bad thing, but sometimes the way it interacts with programming is terrible, and results in there being two ways to do something:
1. the obvious simple way
2. the much more complicated, but secure way
1. the obvious simple way
2. the much more complicated, but secure way
and some environments enforce you doing #2, even if this is only a test that you're doing on a local machine
this is especially bad when you're iterating: Maybe you just need to see if loading this file and then running it through the module will work, and then it turns out you gotta make three source files and set up a FileContentsProviderBean to just load the text file, and UGH this was just to test!
or when browsers decide you can load index.html off the localhost, but it's not allowed to do a JSON.get("file.json") because that's HTTPS only, and file:// doesn't count
and obviously this is important to help secure the browser against users getting tricked into downloading files and then the file JSON requests their bank account's router password and blah blah blah I know what I'm doing stop protecting me from my self
so now you can't just test your HTML+JSON website on your localhost without first spinning up a web server, which just adds another layer of friction to your development cycle
and provides you with absolutely nothing. Of course it'll be on an HTTPS site when it goes live! but right now, it's not, and apparently my browser can't tell the difference between "production" and "my own machine"
so you set up a simple local webserver (python has a oneliner from the command line for it! python -m http.server, or python -m SimpleHTTPServer if you're on 2.x), but then it turns out you can't use some specific feature because chrome decided to arbitrarily limit it to HTTPS to help push the web towards encrypted pages, and canvas fingerprinting means you can't download a PNG off the page...
and now you need a more "real" local server, with valid TLS certificates...
and this is a whole fuck ton of extra friction that just isn't needed for development, but is being pushed on you to make a completely different environment (the open web) more secure.
and the thing about that friction is that you remember it? you internalize how annoying it is to do development on this thing.
so the next time you might have some motivation to work on it, that gets lessened by the reminder that you gotta make sure your node-based HTTP mini-server is correctly installed (you updated Node for another project, maybe that broke it?) or if the certs expired or your new browser didn't accept them
a big part of what helps keep projects going after a long time is minimal friction to getting back into them, you can just pick them up and start coding.
The more that feels like a slog, the less likely you are to keep up working on it
spooky Ske-Lil-ton 🦇@foone friction is the worst. If you just add one additional step to something I'm suddenly 10 times less motivated to do it (or it costs me 10 times more energy to get myself to do it)
(Definitely seems like that effect is much stronger for people with ADHD)
(Definitely seems like that effect is much stronger for people with ADHD)
SnowFox@foone Fortunately, the last time I needed to do this, I already had a domain, ACME, DHCP/DNS, and a webserver reverse-proxy-to-a-local-server config to copy, so it "only" took all day!
The general idea is to issue wildcard certs to each host so I can go to https:// projectname.hostname.mydomain.example, which seems like it should be simple enough if you have a domain, but actually setting it up is mildly annoying.
(Edited to remove superfluous detail.)
William O'Connell@foone I know this is arguably a different kind of pain, but at least in Chrome you can use the unsafely-treat-insecure-origin-as-secure flag to enable HTTPS-only behaviors for specific HTTP origins. Still annoying but I found it easier than dealing with certs.
Jamie BoothTo be fair a lot of developers can't either...
Raven667@foone These things also get ruined by creative malware authors which abuse APIs like this to cause harm, creating the need for additional security controls. The ways that bad actors misuse built-in tools seems unbelievable to people who use their own computers, and the mitigation for unseen threats often feel like being trolled by security nerds.
Luna Dragofelis ΘΔ🏳️⚧️🐱@foone like refusing self signed HTTPS certificates for localhost?
🇺🇦 haxadecimal 🚫👑@foone
But #2 is often the much more complicated, and looks like it might be secure, but isn't, way
But #2 is often the much more complicated, and looks like it might be secure, but isn't, way
@foone This reminds me of `open()` vs `openat()` and the suite of related syscalls, `open` is simple and ergonomic but it's _too_ simple for handling extreme corner cases with hostile local users futzing the filesystem underneath the application, so you end up needing the more complex API when dealing with a more complex and hostile world.
Imma keep reading but I don't know if there is a good answer to this mismatch.
brennen
LR
Alpine Tocsins
tekhedd@foone I was going to say but you beat me to it. It really rots the soul to work with platforms that hate you. Some customers will do the same.
@tekhedd oh yeah. customers that hate you are also a bad one. even if the work itself is fine, having the response to every change you make being "I HATE THIS AND YOU SHOULD CHANGE IT BACK AND THEN DIE" can burn you out just as fast