Matt Might

Huh, I just realized he (she?) was pseudonymous and not Matt Might[0] this whole time. Oops. Also, I wonder about this analysis in the age of AI slop. I wonder how much that removes the identifying bits, vs how much carries through of the original prompt (e.g. topic and guidance). It's interesting that a pseudonymous blogs might take on very generic Claude-voice, which could be worthwhile if the topics were interesting, but could also just be a completely humanless bot. [0] https://matt.might.net

If you want to go further, Matt Mights papers on static analysis are excellent: http://matt.might.net/#papers Older versions of techniques like those described in these papers were the basis of the Stalin scheme compiler by Sisskind. From Sisskind's research statement: Stalin is an optimizing compiler for Scheme that performs whole-program static analysis and uses the results of that analysis to generate extremely ecient code. Stalin utilizes a large collection of static-analysis techniques. It performs a novel form of polyvariant flow analysis that uses iterated monovariant flow analysis to perform flow-directed splitting: cloning of specialized copies of procedures and per-call-site assignment of targets to such clones. It uses the results of flow analysis to perform life-time analysis, escape analysis, points-to analysis, and must-alias analysis. These analyses support a novel form of lightweight closure conversion that eliminates most closure slots, using techniques such as variable globalization and localization, compresses the static backchain, and usually eliminates most closures from programs. It also uses the above analyses to support flow-directed region-based storage management, where run-time garbage collection is replaced with static allocation and deallocation on a per-abstract-value and per-program-point basis. It also performs flow-directed lightweight CPS conversion, using extensions of the techniques pioneered with Screamer, to support extremely ecient…

Blog: https://matt.might.net/articles/ Main site: https://matt.might.net/

You might try OCaml [0] or SML [1] if you want speed, memory safety, and an expressive type system. [0] https://ocaml.github.io/ocamlunix/index.html [1] https://matt.might.net/articles/best-programming-languages/#ml

Applying the principle of least resistance to working out is the right way. The best workout will always be the one you can do consistently. https://matt.might.net/articles/hacking-strength/

Matt has also written a great follow-up, "How to get tenure", see https://matt.might.net/articles/tenure/ Highly relevant for the aspiring researcher, and it describes really well the nonlinearities of (academic) life.

I don't have any resources specific for blindness, though I know a few people who are blind and still have a great quality of life. I have my thoughts on the "disability is not a disadvantage, just another way of being" crowd because that doesn't work for my own situation, but for blindness, I can see the point they're making. There's that old study that looked at what kind of parents give their children the best start and success in life, and after some factor analysis, the single most important attribute was "loving". Disability doesn't change that. You might find Matt Might (of "illustrated guide to a PhD" fame) comforting on the topic of having a disabled child in general: https://matt.might.net/articles/tenure (despite the title this post is not primarily about tenure).

This idea was used to great effect in Matt Might’s “Parsing with Derivatives” paper [0]! And it featured prominently in the Compilers class he taught at the University of Utah. [0] https://matt.might.net/papers/might2011derivatives.pdf

a great blog on programming languages: https://matt.might.net/articles/

This appears to be the official account, not a personal one. If he wants me to take htmx seriously as a prod dependency, I care about how he treats it, all the way from code to governance to community interactions. He has no such obligation to do these things, this is all his choice. I'm not sure why the contention? If you read my comment, it was strictly about production scenarios, not about all credibility for all scenarios. If this project is meant to be treated as fun CRAPL, Matthew Might made a great license for that: https://matt.might.net/articles/crapl/ .

Always a classic: https://matt.might.net/articles/hacking-strength/

This comment reminds me of a great article I read ages ago and had to track down. When you're deeply focused in one area, you're most keenly aware of all the aspects of that area that you aren't an expert in. For example, I consider myself to be a complete novice at relational DBs, but from the perspective of your example truck driving, drilling, construction working, mechanic, I might as well be an expert. I guess it's important to keep in mind the scope domains that you're considering for any given situation. https://matt.might.net/articles/phd-school-in-pictures/ (might not be the original source of the idea though)

Yes. That's how basically all expansion to the field of human knowledge is constructed today. A human can only ingest and understand so much information in so much time. As Matt Might[1] eloquently described in "The Illustrated Guide to a PhD" [2], learning the basics of an entire field of study is what a bachelor's degree is for, a master's degree gives you a specialty, graduate students reading research papers like this one is how you get to the edge of human knowledge...only then can you start building on that sum of knowledge. [1] http://matt.might.net/ [2] http://matt.might.net/articles/phd-school-in-pictures/

I've realized that vitamin D is super important to my overall happiness, I now supplement with D3 and get outside for at least 30 mins in the middle of the day. Additionally I have invested in a small home gym setup (bench, adjustable dumbbells, and a yoga mat) and followed Matt Might's least-resistance philosophy approach to muscle building [1]. [1] https://matt.might.net/articles/hacking-strength/

https://matt.might.net/articles/ Not strictly a software engineer, but a computer scientist (and so many other things), and an extremely smart person in general - worth reading even if you're not interested in academia.

> it's substantially more work to clean and organize the code for publishing, it will increase the surface for nitpicking and criticism (e.g. coding style, etc). Matt Might has a solution for this that I love: Don't clean & organize! Release it under the CRAPL[0], making explicit what everyone understands, viz.: "Generally, academic software is stapled together on a tight deadline; an expert user has to coerce it into running; and it's not pretty code. Academic code is about 'proof of concept.'" [0] https://matt.might.net/articles/crapl/

Do a small research project first to get the taste of it and see how you go. One option is a masters by research; another is an honours degree (this is something we have in Australia and at least in CS includes a research project, not sure about other countries). You mentioned in another comment you're about to start an undergrad degree. I'd recommend getting to know some professors early on and letting them know of your intentions; they'll be able to give you guidance and maybe give you some exposure to an existing research project their group is working on. Also a "substantial original contribution to knowledge in your field" isn't as big as it sounds. See https://matt.might.net/articles/phd-school-in-pictures/

http://www.commandlinefanatic.com/cgi-bin/showpage.cgi?page=home is good deep dive into various topics. Enjoy the gzip explaination Matt might's 'blog' https://matt.might.net/articles/ is good read about various functional ideas and others https://aphyr.com/posts/342-typing-the-technical-interview funny post about how complicated balancing a binary tree could be https://tratt.net/laurie/blog/archive.html some intersting posts about various aspects of programming language tools

Exactly. And let's not forget that the "training" is actually new scholarship, not just learning an existing skill, so even if the PhD doesn't do anything after earning their degree, human knowledge has expanded ever so slightly thanks to their years of effort. This diagram neatly sums it up. http://matt.might.net/articles/phd-school-in-pictures It's the equivalent of learning to code, learning a modern library or framework and its best practices, and then adding a bug fix or new feature.

- SML is old - OCaML has OO cruft and OCaML folks themselves keep telling you "Oh, you don't have to use the OO parts of OCaML" Well then effin give me an ML that's more modern than SML, and has no OO cruft! don't tell me "take this stuff that we think is good, and just ignore parts of it that are bad" (and I'm not interested in Haskell). edit: Matt Might lists only two other languages [0], Scala and Scheme. Both are not ML (though I think some folks think Scala is an ML?) [0] http://matt.might.net/articles/best-programming-languages/

There's a license for that: http://matt.might.net/articles/crapl/ I know free software debaters and open source license philosophers love to hate on this one, but the fundamental core concept of "more importantly, it should absolve authors of shame, embarrassment and ridicule for ugly code" in the context of them choosing to release code or not is a great idea I reckon. (But I agree wholeheartedly with the thrust of your argument, and am of the opinion that if you spent more time on the logo design or website marketing copy for your library than you did writing the code, then "You're doin' it wrong...")

> What if you could easily answer the question "what is everything currently known in mathematics." I love this. I work on this problem a lot. More generally of the form "what is everything currently known in X"? I would love to be able to make statements like "I am familiar with X/Y/Z% of the nodes in Computer Science/Medicine/Arrested Development Season 2". I would love it if the abstract idea of the "dent" (http://matt.might.net/articles/phd-school-in-pictures/) a researcher makes could actually be concretely measured as nodes added/updated/subtracted from some corpus of knowledge. Have you thought about moving the content to a git repo and allowing people to contribute via a pull request?

I found a lot of the stuff on Matt Might's blog helpful. He writes a bit about compiling Scheme to C, which allows me to see what each piece of Scheme is doing in a language I know.[1] Following this approach, I found LISP In Small Pieces[2], Compiling With Continuations[3], etc. There's more but I have to dig it up. [1] http://matt.might.net/articles/programming-with-continuations--excepti… [2] https://pages.lip6.fr/Christian.Queinnec/WWW/LiSP.html [3] https://www.cambridge.org/core/books/compiling-with-continuations/7CA9…

This is tangential, but HOW, HOW, HOW does someone have the time to do all this stuff? http://matt.might.net/materials/matthew-might-cv.pdf I'd love to see a timeline of how some of these super-productive academics are able to fit so many activities into their lives. I doubt I've done 1/10th of what Matt has done in the same amount of time. (And all this while researching, publicizing, and treating his son's rare genetic disorder, in an entirely separate field from the one he got his PhD in: http://matt.might.net/articles/my-sons-killer/)

Argh, this article is going to give researchers the misleading impression that releasing code as open-source is complicated, that you need to maintain it, ask yourself difficult questions, be an expert in programming, find funding to keep it around, etc. But in my field, in most cases the source code is never released at all. That's a far bigger problem that not having support to use it. So fellow academics, please don't use this article as an excuse to not release your code. When in doubt, just push the thing to Gitlab as is, add a README that says "This is research code for paper X and it is unmaintained.", and disappear. It's not ideal, it's not the best way to do science -- but it's much better than not releasing your code. Related: the CRAPL http://matt.might.net/articles/crapl/

I almost forgot to mention: Matt Might has an excellent blog post about what all of these "advanced" programming languages offer: http://matt.might.net/articles/best-programming-languages/

I find Matt Might's post on this topic (Y in JavaScript) the best I seen (even though it's at least 8 years old by now): http://matt.might.net/articles/implementation-of-recursive-fixed-point… It's clear, minimalist, insightful, and even has an in-page live code demo. Bonus points for including fixed-points as a key concept, and memoization as an extremely useful technique.

This was a good article! It's (reasonably) missing one of my favorite parsing algorithms, though, which is Might's "Parsing with Derivatives" [0, 1]. It's not very efficient compared to some other algorithms, but I think it is very elegant conceptually. [0] Blog post: http://matt.might.net/articles/parsing-with-derivatives/ [1] Paper: http://matt.might.net/papers/might2011derivatives.pdf [2] Improvements: https://michaeldadams.org/papers/derivatives2/derivatives2.pdf

http://matt.might.net/articles/best-programming-languages/ "I don't think Java is all that bad, and I can enjoy well-done object-oriented programming." This is probably the most accurate opinion of Java the language I've seen, one that isn't tarnished by what anyone has seen in any proprietary codebase. I would rather program in Java the programming language than Javascript any day of the year, even if I dislike the vast majority of popular Java frameworks like Spring, Hibernate, etc.

Well, i would love to see some applications of delimited continuations other than those mentioned here: http://matt.might.net/articles/programming-with-continuations--excepti… . Most languages have support for these applications. The only thing other than that i have seen work is continuation based web servers.