HN user
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].
For the mathematically inclined, EWD717 and EWD765 have two really cool problems.
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.
Thanks!
Bloomberg also does use OCaml by the way, although probably not to the extent of Jane Street.
The comments are wildly fragmented in this thread. I agree with @torginus, the article has less and less of anything useful to people that want to get into compilers.
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
I am whole off the vim (&friends) trend but my 2c-
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.
Yes I am talking about the help text in echo area. In newer versions apparently they only show a single line by truncating the eldoc-doc-buffer content(not super sure on this but they do truncate to 1 line). eldoc-echo-area-use-multiline-p does not work for that sadly.
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.
Slightly off topic here but do you (or anyone) happen to know how to get old Eglot behaviour back of showing entire types and parameter information instead of only the first line? It has been bugging me whole week and I cannot seem to find any fix for this.
No affiliations, just found it cool.
Release video: https://www.youtube.com/watch?v=jm_0nRQEn_o
Why Plan 9 seems to be 'much' more popular/discussed and not Inferno?
[0] https://en.wikipedia.org/wiki/Inferno_(operating_system)
How far are the problem sets doable for non Harvard people? I want to do the psets as well as maybe extend the OS with some ideas but the license is not there as well? @ekzhang
Why not bloomberg instead lol
Godement in his analysis exposition briefly talks about this, it was all hand drawn.
Off topic but without going RTFM, is there a guide that goes through setting up emacs 'with the modern way'? I have done it before but in a mish-mash way where I want something that tells how to go from configuring comp-speed, elpaca, eglot, auto treesitter etc
Can https://www.underhanded-c.org/ also please come back!
I am probably misunderstanding your requirements but if you are looking for something like regex101 then https://omrelli.ug/nearley-playground/ and https://bnfparser.firebaseapp.com/ although not sure how much 'practical' are they. Googling gives [2], [3], [4].
[2] https://mingodad.github.io/parsertl-playground/playground/ not sure.
I was playing around with Fortran (modern-ish) recently was pretty impressed with the entire ecosystem. `fpm` is really really nice to work, pretty decent LSP server (fortls) as well as good enough documentation.
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.
See https://wiki.alopex.li/SurveyOfSystemLanguages2024
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).
Yes, thank you. That is the Douglas Thain book I meant. (compilerbook.org seems to work for me, only broken thing would be the semicolon).
I wrote 'multiple codegen architectures' instead of 'multiple architectures for codegen'.
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.
Regarding the language design part, many universities I know of offer a {Advanced} Programming Languages class later on after a Compilers 101 class and that is where many of the topics like EBNF, Grammar Design along with different constructs are done.
Besides, for someone learning it for the first time I think designing a new language seems a bit difficult.
I just got over writing 2 (well 2.5) toy compilers and I think a lot of the material in the compiler-teaching space lack some subtle developmental aspects.
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/
I am hazy on the details but my instructor briefly told us that the 1979 edition had better problems and had topics for the advanced undergraduate. The major thing for us as students was that the 1979 was much shorter to use and concise to the point of being a good handbook.
(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)
This is especially true if you consider all the "variations" - the second updated edition (global edition) which should rightfully be a third edition as it has two additional chapters and the two volume precursor texts: The Theory of Parsing, Translation, and Compiling Vol 1 & 2.
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.)
+1.
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'.
https://github.com/tntaooa/tnt/ Closest I know to an actual book in that style in modern LaTeX. The current edition (main.pdf of that repo) however replaced all the old styling by the looks of it, luckily the antique pdf is viewable here: https://github.com/tntaooa/tnt/blob/63675f2f7dd6b0490d096754...
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.
Would also like to mention (tab-rs)[0] which has a much more unconventional take on multiplexing.
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?
Agree with all but autocomplete should either be a hidden feature or disabled by default since I think it takes away from the immersion as well forces you to recall.
Maybe enabled on a NG+?
You are probably thinking about Programming from the Ground Up by Jonathan Bartlett. There are many others in the same style though. He also has a newer book if I recall right.
https://www.amazon.com/Programming-Ground-Up-Jonathan-Bartle...