Alternatively beside which-key, hydras exist which are very nice for certain contexts (dired in the particular case for me) and provide a nice shortcut interface whenever activated. Demo at [0].
74 karma · joined February 9, 2025
A while back someone posed EWD765 for an alternate solution, I don't recall if any other solution was found. That was my introduction to these.
Bloomberg also does use OCaml by the way, although probably not to the extent of Jane Street.
Anyways, the "Who .. hires compiler engineer?" section is fairly vague in my opinion, so: AMD, Nvidia, Intel, Apple, Google definitely hire for compiler positions. These hire fairly 'in-open' so probably the best bets all around. Aside from this, Jane Street and Bloomberg also do hire at the peak tier but for that certain language. The off beat options are: Qualcomm, Modular, Amazon (AWS) and ARM. Also see, https://mgaudet.github.io/CompilerJobs/
I seriously attempted getting into compilers last year before realising it is not for me but during those times it felt like people who want to be compiler devs are much much more in number compared to jobs that exist (yes exist, not vacant).
The common way to get going is to do LLVM. Making a compiler is great and all but too many people exist with a lox interpreter-compiler or something taken from the two Go books. Contributing to LLVM (or friends like Carbon, Swift, Rust) or atleast some usage experience is the way. The other side of this is doing GNU GCC and friends but I have seen like only one opening that mentions this way as being relevant. University level courses are rarely of any use.
Lastly, LLVM meetups/conferences are fairly common at most tech hubs and usually have a jobs section listing all requirements.
A few resources since I already made this comment too long (sorry!):
[0]: https://bernsteinbear.com/pl-resources/ [1]: https://lowlevelbits.org/how-to-learn-compilers-llvm-edition... [2]: https://www.youtube.com/@compilers/videos
The helix situation is still miles better for up and running asap compared to dancing with files/lua on lazyvim. Just having to refer to docs to install a plugin, writing sane remaps etc eats up time. If you really just speedrun everything under an hour good for you. But for the rest, a lsp is a one package manager install away (even on windows scoop seems to have become the de facto), editing a toml is much easier than fiddling with the lua api/vimscript "just" to set some variables.
(Not a helix user though I have tried both vim/nvim/helix)
The only problem for me was the keybindings work good unless my vim instincts kick in where I become slow. The other one was lack of plugins.
Apparently this was changed only recently. I am surprised not many people know/talk about this change. Still looking for a fix.
Edit: I do agree it is annoying but for unknown codebases it helped me a lot.
Release video: https://www.youtube.com/watch?v=jm_0nRQEn_o
[0]: https://en.wikipedia.org/wiki/Inferno_(operating_system)
[2] https://mingodad.github.io/parsertl-playground/playground/ not sure.
I am not sure however I like the verbosity of it where if you are using 'raw' editors without snippet support, it becomes a chore very soon.
All in all it is nice to use and play around with.
and the related discussion https://lobste.rs/s/c3dbkh
Serious total MSLs that have a defined memory model to allow "low level" operations seem to be scarce if not any. Hence I do not think there is any single one that comes between C/Zig and Rust.
I would have said https://www.hylo-lang.org/ but, personal opinion, seems like there is too much going on as well. See also https://vale.dev/
P.S Mind mentioning what FP-like features are in Rust? (Genuinely have not looked into Rust that much but I am interested).
As far as I have done in the toy compilers and seen the things in actual production ready compilers, the codegen is still very much tied to the one thing or the other rest llvm.
Besides, for someone learning it for the first time I think designing a new language seems a bit difficult.
I wish there was a course designed somewhere which talked about more ingrained issues: how to structure/design the AST[0], buffer based vs noncontextual tokenization/parser design, index handling and error sync in the parser, supporting multiple codegen architectures, handling FFI, exposing the compiler as an API for external tooling, namespaces and linkage handling etc. etc. etc.
It is refreshing to see how Carbon designed some of its components (majorly the frontend, yet to take a look at the backend) as it touches on some of the subtleties I mentioned. If someone is starting out on writing one, I would recommend taking a look at it or any of the talks.
Always nice to see new material coming up. A few resources that I would like to mention would be dabaez's compiler course, Khoury college's compiler course (in Rust, previously i think and Ocaml), Nora Sandler's book as well as http://compilerbook.org; Which I consider to be the best guide out there for writing small learning compilers, the videos are good as well.
[0]: Some related content that I enjoyed reading: https://lesleylai.info/en/ast-in-cpp-part-1-variant/
(We do Theory of Computation/Formal Language and Automata Theory as a dual sem course meant to be both a junior and a senior class and thus the 1st edition suits the course better.)
Googling gives https://cs.stackexchange.com/questions/149072/hopcroft-ullma... (see the question for the links)
The first one was also perfectly sized and not making it a bulkier text like the current CS curriculum texts (CLRS, OS:Concepts, Korth's DBMS etc.)
To elaborate on this, the original Introduction to Automata Theory, Languages, and Computation, by John Hoffcroft and Jefferey Ullman (The one with the black cover is the 1979 edition). My instructor, even in 2024, made us use that one instead of the newer one.
The other text if i recall right is Tanenbaum's Computer Networks book, where there is a significant portion of bloat that does not really fit there although my source for this is a review for the book.
K&R 2nd Edition was rushed but I personally wouldn't claim the older edition was 'better'.
The extracted style files are here (as a package): https://github.com/proafxin/antique_book
On a personal note, getting the text (for MIR style books) is the somewhat easy part, see https://tug.org/FontCatalogue/oldstandard/ The hard part is the symbols (er, math). For UK style old books (MacMillan style), there is the "literat" package, "Literaturnaya" fonts, which get close but the Math symbols are a miss.
It is sad that it has not been maintained in a while (written in rust) as I much prefer the low cognitive load approach it presents (just fuzzy find) as well as the workspace feature.
Would be interested in knowing if there is something similar and maintained.
P.S. Does anyone here know how to make GNU Screen start up by default on a terminal launch?
Maybe enabled on a NG+?
https://www.amazon.com/Programming-Ground-Up-Jonathan-Bartle...