Tom Tromey

[continued from above due to size limit]

What I'm referring to is incremental recompilation with the following properties:

1. automatic correctness

` - that is, a compiler change not explicitly updating anything related to dependency tracking should at most result in conservative coarser-grained behavior, not unsoundly cause untracked dependencies

` - manual cache invalidation logic is a clear indicator a compiler isn't this - e.g. this rules out https://gcc.gnu.org/wiki/IncrementalCompiler (maybe also Roslyn/C# and the Swift compiler, but I'm not sure - they might be hybrid w/ automated coarse-grained vs manual fine-grained?)

` - the practical approach to this is to split workload into work units (aka tasks/queries/etc.) and then force information flow through centralized "request"/"query" APIs that automatically track dependencies - see https://github.com/salsa-rs/salsa for more information

` - research along the lines of ILC (Incremental Lambda Calculus) might yield more interesting results long-term

` - outside of a compiler, the only examples I'm aware of are build systems like tup (https://gittup.org/tup/) or RIKER (https://github.com/curtsinger-lab/riker) which use filesystem sandboxing (FUSE for tup, ptrace/seccomp-BPF for RIKER) for "automatically correct" build dependencies

2. fine-grained enough

` - at the very least, changes within function bodies should be isolated from other bodies, with only IPOs ("interprocedural optimizations", usually…

Just want to give a shout out to the people who have been improving GDB's Python API over the years (I think it first appeared about 10 years ago). It seems like a lot of it is due to Tom Tromey? [1]

This is a super useful feature that I just used. I have a DSL for algebraic data types in C++ called ASDL [2], and I wrote a very small Python plugin that pretty prints the types.

Basically it automates the process of looking at the runtime type tag, and downcasting to the right variant, so you can see all the fields in the debugger. (Variants are naturally modeled with inheritance, and you still have type safety)

This makes debugging the code way easier. I basically enhanced C++'s type system and now the debugger also understands it!

It works on the command line and the Eclipse GUI. Although I should get around to requesting an open source license for CLion, because I think it is significantly more polished.

-----

GDB is very old, and has sort of a bad reputation for usability, but it's getting better after all these years! This scripting power can make up for the usability in some cases (and maybe CLion will give the best of both worlds)

https://lobste.rs/s/h7f6qk/what_debugging_technique_did_it_take_you#c_pqoh28

[1] https://tromey.com/blog/?m=201809

https://tromey.com/blog/?p=927

[2] What is Zephyr ASDL? https://www.oilshell.org/blog/2016/12/11.html

ASDL is mentioned in the post about Ungrammar, on the front page now:…

Thanks for your clojure work. I'm using a lot of your stuff and I am grateful you take the time to write and release it.

"In the mean time, the link to package.el for Emacs 23 is right at the top of marmalade-repo.org: http://bit.ly/pkg-el23

You know that, but nothing on the page indicates it. In fact, that page leads me to believe it is the same version as tromey.com hosts. It isn't made clear that marmalade is a fork rather than an additional repository.

Plus that package.el does not integrate (or include instructions on how to integrate) with Emacs the same way the one from tromey.com does when you run the code on http://tromey.com/elpa/install.html