miniblog.

... and my third refactoring with Cursor changed some function calls that I didn't want it to modify. Subtle. I've had the most success with AI coding tools when I know exactly what I want the output to look like.
I'm pretty impressed with Cursor: I've successfully asked it to perform codebase transforms in English, and it's worked! E.g. "Replace all calls foo(..., true) with foo_immediate(...) define a foo_immediate function". I'm still reading the diff and checking tests -- it's still AI after all.
An ad hoc, informally-specified, bug-ridden, slow implementation of half of a text adventure game -- or as I like to call it, a compiler.
TIL Rust has an ambiguity `if Foo {}` -- is `Foo` a value of type bool, or a struct? Rust solves this by defining a grammar production 'any expression except struct literals' and using it in this position.
It's so strange that we talk about languages being slow, and have done for years. Computer performance has increased so much in this time. https://hbfs.wordpress.com/2009/11/10/is-python-slow/ (shared on HN in 2009) discusses Python being slow. My underpowered Thinkpad has 20x the single-threaded performance! https://www.cpubenchmark.net/compare/73vs3766/AMD-Athlon-64-4000+-vs-AMD-Ryzen-5-PRO-4650U Maybe *relative* performance of languages matters more?
It's so strange that we talk about languages being slow, and have done for years. Computer performance has increased so much in this time. https://hbfs.wordpress.com/2009/11/10/is-python-slow/ (shared on HN in 2009) discusses Python being slow. My underpowered Thinkpad has 20x the single-threaded perf!
I like that most LLM UIs show your previous queries prominently. When figuring out where LLMs are useful in your workflow, it's nice to see what worked well (or not) in the past. Web search doesn't have this property. I rarely look at what I've previously googled.
I'm a fan of the Software Unscripted podcast, and I particularly enjoyed this recent episode about CrowdStrike and security culture: https://www.youtube.com/watch?v=rzjaZssBEiI The guest (Kelly Shortridge) compares attackers to lawyers trying to find loopholes. This is such a great analogy.
One interesting design choice in Emacs that I haven't seen in other editors: reserved shortcuts. An Emacs extension shouldn't use F5 through F12, or Ctrl-c LETTER. This lets users configure their own shortcuts. https://www.gnu.org/software/emacs/manual/html_node/emacs/Key-Bindings.html Does it exist elsewhere? I miss it in VS Code, where e.g. all the Fn keys are already assigned.
One interesting design choice in Emacs that I haven't seen in other editors: reserved shortcuts. An Emacs extension shouldn't use F5 through F12, or Ctrl-c LETTER. This lets users configure their own shortcuts. https://www.gnu.org/software/emacs/manual/html_node/emacs/Key-Bindings.html Does it exist elsewhere?
Really cute approach to reporting type errors: when there's a type error, show an example of a runtime error that the type check has prevented! Data-Driven Techniques for Type Error Diagnosis https://escholarship.org/uc/item/59s4h4pv
Difftastic has been cited in a paper! Modernizing SMT-Based Type Error Localization https://arxiv.org/abs/2408.09034 The authors use difftastic to work out which parts of a buggy program have actually changed, a great use case :)
Modernizing SMT-Based Type Error Localization
Modernizing SMT-Based Type Error Localization
Traditional implementations of strongly-typed functional programming languages often miss the root cause of type errors. As a consequence, type error messages are often misleading and confusing - particularly for students learning such a language. We describe Tyro, a type error localization tool which determines the optimal source of an error for ill-typed programs following fundamental ideas by Pavlinovic et al. : we first translate typing constraints into SMT (Satisfiability Modulo Theories) using an intermediate representation which is more readable than the actual SMT encoding; during this phase we apply a new encoding for polymorphic types. Second, we translate our intermediate representation into an actual SMT encoding and take advantage of recent advancements in off-the-shelf SMT solvers to effectively find optimal error sources for ill-typed programs. Our design maintains the separation of heuristic and search also present in prior and similar work. In addition, our architecture design increases modularity, re-usability, and trust in the overall architecture using an intermediate representation to facilitate the safe generation of the SMT encoding. We believe this design principle will apply to many other tools that leverage SMT solvers. Our experimental evaluation reinforces that the SMT approach finds accurate error sources using both expert-labeled programs and an automated method for larger-scale analysis. Compared to prior work, Tyro lays the basis for large-scale evaluation of error localization techniques, which can be integrated into programming environments and enable us to understand the impact of precise error messages for students in practice.
LLMs are a really accessible machine learning technique. I dabbled with text classifiers a few years ago and the APIs were way more involved. (system_prompt: String, input: String) -> String I can prototype with this much more easily!
Bootstrapping a language can be immensely satisfying. I've added the ability to define stub types in the Garden stdlib and suddenly I don't need to special-case Int or String! They're just normal type declarations.
I'm a huge fan of Swift's 'Error Handling Rationale' design document: https://github.com/swiftlang/swift/blob/9315673c003875158852579bd1f33480cdec5461/docs/ErrorHandlingRationale.md#fundamentals It carefully defines terminology and compares with other languages, so you can understand Swift's position and preference in the design space.
Showing 181-195 of 7,549 posts