5,521 karma · joined November 4, 2010
On macOS, pressing ⌘+comma with Ghostty in focus opens the config file.
Quit and reopen Ghostty to load the updated config (or bind another key to the reload_config action: https://ghostty.org/docs/config/keybind/reference#reload_con... ).
Keybinds are explained here: https://ghostty.org/docs/config/reference#keybind
During the beta I had it configured like this on macOS:
keybind = global:cmd+space=toggle_quick_terminal
quick-terminal-animation-duration = 0.1
But the way you like to approach problems is heavily influenced by your history of solving them, what tools were available at the time, what you chose to adopt, and how often you revise that toolset.
It's not elitist to say that people tend to use what they've always used, which was my point: "how do people cope without LSP/LLMs?" tends to be "the way they've always coped" — efficiently or otherwise.
And it tends to track with when you began programming or using specific tools. A vim user who adopted vim in the '90s is more likely to have a light config than those who adopted it more recently, where I see heavy plugin and plugin manager use, LSP integration, pre-configured distros, and Lua-based configs.
1. The HLSP user
This group does use an LSP, it turns out, only via you as the conduit: you are their Human Language Server Protocol. They'll ask, ‘can we pair today?’. From that point, navigating code, looking up method names and signatures, and flagging syntax errors before runtime or compile time is your job. How they find their way around when you're not there is unclear, but it's likely slower.
2. I am one with the machine
This crowd has been wrangling code long before IDEs, LSPs and LLMs. They've amassed a terrifying arsenal of tools to find files and references, bulk-rename, pull up docs, and twiddle bits in ways that looks fluent and natural enough when _they_ do it but would take months or years for you to learn if you didn't give up and go back to your IDE. When you ask them _how_ they just did something, they either pull up a short page of Elisp and say, "it's really quite simple we just reverse the node tree and iterate over the folded quarkenspace", or — if they're a vim user — say something like, "oh, that's just the hiboscus plugin, but piped through smark".
So the response to "how do you do it?" seems to be broadly summed up as, "the way we've always done it".
Group 2 isn't necessarily _better_ than LSP/autocomplete/heavy LLM users (people who are very proficient with more modern tools can look like magicians too). The LLM-free crowd were just forced early to become proficient, they've gotten very good with their home-rolled methods, and — in many cases — they probably wouldn't benefit that much from LSPs, or they use them but with features that bug them switched off.
Group 1 would probably better be served by an LSP but either don't believe in the benefits or is just comfortable with their current setup and feels no pressure to change.
This classroom timetable shows the utility of that, and it’s not so hard to imagine it extending to other interactive or non-interactive uses (meeting room reservation, digital store pricing, bus timetables, etc.).
"…thanks to hot reloading, which — for once — is useful…"
That seems to sum up the sentiment that hot swapping in Erlang has uses but they're generally not aligned with what Erlang is typically employed for. It seems like it would be great for tight game dev loop feedback and iteration too, for example, but that's not a traditional use of Erlang either.
https://www.youtube.com/watch?v=XQS9SECCp1I
But I almost never hear Erlang/Elixir/Gleam folks talk about this benefit of the Erlang VM now, even though it seems fairly unique and interesting. Has the community moved away from it? Is it just not that useful?
Or advice for a path to be able to build things like Tiny Glade? (Other than "start 20 years ago".)
Procedural art is fascinating and worthy of a deep dive too since it combines art, modelling, rendering, programming and maths (constraint solvers, discrete optimization, more).
Anastasia Opara (“procedural art nerd”) has a Gumroad with procedural art tutorials that show how to create environments procedurally with Houdini: https://anopara.gumroad.com/ (the first one is free)
Tomasz Stachowiak (“technical debt generator”) gave a talk at GPC 2024 earlier this month called “rendering tiny glades with entirely too much ray marching” (no recording I can find yet but worth keeping an eye on): https://www.graphicsprogrammingconference.nl/#tiny-glade
Outside of the Tiny Glade team, Oskar Stålberg (Townscaper) is worth following for his frequent insights into proc-gen: https://x.com/OskSta
Sounds perfect. Much better than having to negotiate your way out of a $1000 bill you don't expect to see.
Building a business on blank cheques and accidental spends is shady. It's also a large barrier to adoption. The more times devs see reports like, "I tried [random 20-minute tutorial] and woke up to a bill for my life's savings and luckily support waived the fee this one time but next time they're coming for my house", the less they'll want to explore your offerings.
It's a shame because F# is a beautiful language — it's fun to read, write and maintain. .NET now works well cross-platform with editors other than Visual Studio. General perks of .NET like cross-platform compilation are a nice bonus, for example, on macOS I can:
brew install dotnet
dotnet new console -lang F# -o HelloWorldApp
cd HelloWorldApp
dotnet publish -c Release -r osx-arm64 --self-contained
dotnet publish -c Release -r osx-x64 --self-contained
dotnet publish -c Release -r win-x64 --self-contained
dotnet publish -c Release -r linux-x64 --self-contained
There is a decent multi-platform UI framework called Avalonia: https://github.com/fsprojects/Avalonia.FuncUI
There are good actively maintained web frameworks: https://fsharp.org/guides/web/#web-frameworks
There are some passionate people writing great books about F#: https://fsharpforfunandprofit.com/ddd/
Most of F#'s adoption issues seem to be because:
1. It's tough to convince people outside of the .NET community to use .NET.
2. Most of the people using .NET use C#.
3. It's hard to convince C# users to adopt F#. (See https://www.reddit.com/r/dotnet/comments/16m0wdj/why_dont_yo... and similar threads.)
I'd love to work with F# full-time, but — short of starting my own company using it or convincing Microsoft to pay me to help them showcase its benefits — it's been hard to find work with F#, which drove me to spend time with other languages.
So generic battery manufacturers could presumably buy the tape from Tesa, license production themselves, risk producing their own variants, or supply replacements without electrical debonding (the consumer probably doesn't care that the replacement battery doesn't use the same debonding tech their original battery used).
They told him to hand over whatever he'd got:
"Douglas happily built his reputation for (at this stage, merely) sailing close to the wind when it came to publishing deadlines by telling interviewers that he had been ordered to literally stop writing and hand his manuscript over to a courier no matter where he had got to…"
— The Frood: The Authorised and Very Official History of Douglas Adams and The Hitchhiker’s Guide to the Galaxy by Jem Roberts"
He was famous for scraping or missing deadlines from the very start, and openly admitted to it:
"All of my life I've been attracted to the idea of being a writer, but like all writers I don't so much like writing as having written. … each time I meant to try to write something, I'd miss the deadline by two weeks."
I didn't think anything was seriously wrong, just wrong enough to be annoying for the first few days because I wasn't learning much and the system is rigid and zero trust — I have no way to tell it I understand except by hard proof.
It's also a balancing act, though. Under-estimating a student's ability on purpose might frustrate them a little but offer a small confidence boost while they're still learning the system and finding a daily rhythm. Over-estimating could make them feel stupid and intimidated and drive them to drop out early.
> …I couldn't really find a listing of how big the courses are time-wise.
I spent about an hour a day and it projected a course end date of about two months away. (When you commit to an XP daily pace, it estimates the completion date for the course you selected.) Most courses seem to need 30-90+ hours of study, but it will vary by subject and student since the placement test may put you ahead of or behind others.
> Also did you find it doable to keep up with the daily workload?
No. I set an XP daily pace I felt comfortable with (I think 40XP?), saw the projected end date was far further than I had hoped, then increased my daily pace commitment but couldn't match that consistently due in part to the compounding gripes I mentioned in my parent comment and — frankly — my own lack of motivation.
To stick with MathAcademy or any learning program it's better to have strong motivation in the form of a concrete goal you are working towards. I didn't have a strong sense of that — only a much woolier, "I think a stronger maths foundation would unlock more for me as a software engineer", which is the kind of goal that makes quitting too easy.
If I were to subscribe to MA again I'd first clearly define a goal, like being able to write an AI or game engine physics library from scratch (and then also a strong reason why those things feel important to me, like getting a job in the field or whatever). But I've since moved on to learn other things (design, drawing, painting) and find the motivation flowing much more naturally there. Partly that's because the positive feedback loop flows better for me with art than with maths (the progress week-to-week is highly visual!) but also because I'm working toward a more strongly defined goal.
It's not perfect, though, and my experience differed a little:
> MathAcademy excels at identifying exactly what you need to work on, zeroing in on your weak spots and areas for improvement.
It doesn't excel at this yet. It claims to have an "adaptive diagnostic assessment [that] will identify the correct starting place for the student" but this didn't work very well for me. I ended up sitting through many questions that felt insultingly easy (e.g. number lines) without a way to skip them. You have to answer the questions quickly and correctly to prove you understand them, which is probably a defence against students clicking "I understand this" for everything when they don't, but it felt very tedious.
If you get a lot of questions wrong on a subject it ends the topic early with a (somewhat discouraging), "ending your session early due to poor performance" (why not just, "let's come back to this later"?). But if you get lots of questions right quickly it doesn't seem to have a similar, "lesson ended early due to great performance" or "ok, it's clear you already understand this" — it just continues to drill you, which feels very tedious.
> For less than the cost of a single hour with a private math tutor, MathAcademy provides you with 24/7 access to what is essentially a tireless, expert math tutor.
It's less like a tutor and more like a choose-your-own-adventure textbook with tests, spaced repetition and guided pathfinding. And that's great! But I missed things I'd get from a tutor, like the ability to ask for clarification. MathAcademy uses terms in questions or descriptions that it hasn't defined or explained previously (or perhaps it had defined those terms in earlier lessons it skipped?). I ended up looking things up from outside sources or taking a 30-minute detour into YouTube to fill in the gaps. Which is fine when it's occasional, but annoying when it's every other session. Sure, it's "adaptive" but it's not responsive like a real tutor.
The overall tone is that of the forever unimpressed tutor — quick to penalise and very light on encouragement. Full gamification with gold stars and badges and weapons upgrades would be annoying, but I'd like something more than "you scored x". (For example, immediately show me how my recent result has affected my overall understanding of the subject as a progress bar.)
The UX of the site is tedious when drilling questions daily. The slow round-trip before seeing if your answer was correct becomes grating; if this can't be done client-side I would love to see improved performance server-side.
On the whole, though, yes, it's worth checking out if you're serious about maths improvement.
https://www.newyorker.com/culture/the-weekend-essay/why-ai-i...
Native GUIs offer far better accessibility (TUIs are not screen-reader accessible, and neither is Emacs' GUI currently), hugely improved UI flexibility and consistent developer APIs (Emacs GUI is inconsistent across platforms and tricky to work with, every Neovim plugin reinvents ways to draw modals/text input because there's no consistent API), reduced redraw quirks, better performance, better debugging (as a Neovim plugin dev I don't want to spend time debugging user reports that relate to the user's choice of terminal emulator this week and not to Neovim or my plugin code).