JHonaker

You have to make almost the exact same choices when you rely on fequentist tools. The main difference is they’re pre-made during the development of the tool, so you don’t get insight into what they are without studying the theory behind the test.

Yea, these are 100% exactly how you should approach a research problem, in mathematics or otherwise.

Literally the first part of almost every research paper is outlining how this thing you're about to talk about is similar and dissimilar to other things. That's often followed by a simplified description of the idea. Then that's usually followed by the thing in full generality.

I meant more “what are you actually completing?” And “how much?” I haven’t found the completions to be particularly helpful.

For instance, I’m often fighting incorrect array indices and slices, pulling out magic numbers into variables, decoding some one-liner completion, or figuring out what’s usable and what I need to cut out and replace in a larger block.

What’s really struck me is how much I really want Agda style hole-filling completion. I want to just be able to type a variable name and have it destructure cases for me. That happened a few times, and it was really nice. I’d forgotten how nice it was to be able to do that in Agda. I want that everywhere.

Also, just noticed who you were, I really enjoyed some of your Lisp books.

Do you mind reflecting a bit on your use of Copilot? I've been trying it out, but I haven't found it to be particularly helpful.

I really find it to be more annoying than helpful. The mental burden of figuring out what the code is actually doing when a large chunk appears is exhausting, and it leaves me with a false level of understanding similar to the feeling of competency you get when you type out a tutorial's examples.

Underwhelming is how I'd describe my experience with ChatGPT too. There are so many people making claims of ridiculously improved efficiency, that I'm really unsure if it's me or not.

Get ready for the next generation of Muzak

> Do I understand it correctly that Kalman filters are supposed to give a better estimate of a value from noisy observations than just averaging the observations?

Yes, but with a big caveat. Your observations are related by something like the transition mechanism. You can't just apply a Kalman filter to every problem and expect to get better results.

A Kalman filter is traditionally used in estimating something that moves over time (but can be used for more than just this). Think a person moving in a video, or some other sort of random walk. By assuming some sort of relationship between two successive timepoints/measurements, like speed and current heading, we can blend the information from a model for motion with the model from noisy measurements to get a better estimate of the position/value or of the entire motion history.

If that motion model is meaningfully incorrect, then you don't get improved estimates.

A lot of the ways that people have extended them have to do with incorporating more sophisticated motion models, like dealing with wheel slippage in robotics, so your heading direction might have error now, etc.

Or just “random sample conditioned on the prompt.” How did we get to the point where we started calling random samples hallucinations.

This is nand2tetris.

Hear! Hear! It’s really frustrating to see so many people act as if there is nothing but neural network based approaches that work for anything moderately complex.

It’s not a good sign that there is little to no understanding of even recent history in the academic disciplines becoming inundated with NNs. Just today I skimmed an article that had a “history” of NLP that completely ignored symbolic and statistical approaches that focus on, you know, parsing natural language…

The main problem is the extrapolation of the “small world” we construct with mathematics to the “large world” of an application.

Your model can be completely internally consistent and allow you to study things in the context of your assumptions perfectly, but that doesn’t mean it doesn’t have critical flaws that disqualify any learning about the system you’ve modeled.

The lack of understanding about what implications a representational choice have for the kinds of relationships a mathematical model can describe, and the lack of understanding concerning what are and aren’t critical domain components to model that’s difficult.

People often forget that there are two translation steps that have to take place. Domain -> Math -> Domain. That second one is too often implicit or assumed to follow, especially in ML.

I’ve had the opposite trajectory, and I think there’s a lot of danger in a wider adoption of your stance. The deeper I go on STEM things, the more I realize everything is, in your words, “bullshit.”

I want to be clear that I would phrase that as “based on consensus,” and not as bullshit. I have seen so many doomed/failed projects/models that have come up because people say “well, it’s math, so it has to be right.”

The fact that you acknowledge that it wasn't really a vacation that would help you in that situation, and you don't know how long it was says everything you need to know.

I'm not going to tell you how to live your life, but I want you to know that it's okay to not do everything. In fact, you can't do everything. Sometimes it doesn't seem like it, but sometimes you just need someone else to say it.

It sounds like you’re on the edge of burnout.

When’s the last time you took a day off?

It’s called IceCat, and it already exists.

The problem I see with this is that it’s not very useful for people to know if something is a +3 or +4.1 position. The qualitative descriptions that underlie that rating is what’s important. How does my pawn structure compare to my opponents? What is the balance of minor pieces (knight and knight vs bishop knight, BB vs KK, etc.)? That’s how you get to understand chess.

It really isn't talked about enough. I am contemplating leaving my PhD despite being ABD with the majority of the interesting work done simply because the neglect it inflicts on my family is the cause of the overwhelming majority of conflicts in my life.

I truly love working on the problem, investing time in research papers, and experimenting, but I have no desire to stay in academia. Plus, I have a well-paying full-time job (that I took during the pandemic to save my wife from having to shoulder our living expenses basically single-handedly while growing our child inside of her).

> Suffice it to say I'm taking steps make sure my next gig has more room.

I hear you. It's crazy how mentally abusive a lot of people's relationship with their PhD is. I'm convinced it's one of the reasons so many people with PhDs marry other PhDs. They're the only ones that "understand" the level of single-minded devotion you have to have to be an early career researcher.

I have heard of it. I wasn’t really trying to draw specific parallels between Acme and Smalltalk as similar editing environments. I was just lamenting that two of the most interesting pieces of software I’ve used recently are both older than me, and very little except for efforts to recreate those systems exactly on modern hardware has quite the same feeling of freedom and creativity. They really feel like they are there for you to mold into what you need a computer to be, not tell you how to use a computer.

It’s probably not fair to say that we’ve lost a capacity or appreciation for creativity and novel ideas. In sheer volume, there are probably more people doing XeroxPARC level crazy stuff now than then. It just feels like way more investments are made to copy the thing someone else is doing but tweak it slightly than on truly large moonshots.

Part of this is probably the homogenization cause by mass, instant communication, and not forcing you to wonder, how did they do that, and how would I do it differently. It’s a double edged sword though. Hell, I feel like part of the reason some of this stuff didn’t catch fire and spread was because of the limited ability to share and talk with people too.

I don’t know what the right answer is. I just want more cool shit.

Your problem with Acme is you don’t grok Plan 9. [1] In Plan 9, everything’s a file. Acme in particular represents open buffers and windows as files on disk too. I don’t mean as copies of the text necessarily, but as sockets basically where you can send and receive data about a particular thing inside Acme. It’s kind of wild just how exposed it is. It’s not like you’re sending info to a single process server like an LSP server of today, no, you’re literally getting a file ID to go back to and write to when you finish doing what you’re doing.

Writing a plug-in is actually completely language agnostic. It’s just standard file IO.

Any time you middle click the name of a script, it executes that file by looking it up in a PATH equivalent (pretty sure it’s also project local as well, but I don’t remember).

This is really powerful for two reasons: everything’s an editable text field from your menu bar, your window bar, and the buttons on them; and chorded selections, basically you can send a selection to a command by selecting and then clicking on another piece of text to determine the command.

This allows you to create a UI tailored to whatever you’re doing as you’re doing it. If you watch someone program with Acme, they’re writing little snippets in their status bar to do common tasks, or for more involved things, they’re just creating a new buffer and typing or cut and pasting some relevant code they need to search different parts of (because searching is just one mouse click away). The best part is, you can just save and load that buffer for later. It’s just a plain text file.

It’s definitely a change up from the keyboard-driven focus we’ve come to see, but again, I think we gave up on the mouse way too quickly. If you’re really honest with yourself, I think you’ll find you aren’t constantly clipping around at 1,000 key presses per minute in Vim. You’re spurty, you sit and think, and then you type. Once I started thinking about hands on mouse time as thinking time, then it wasn’t nearly so unacceptable. I even came to prefer it (gasp).

[1] Sorry I couldn’t resist referencing the classic Vim/Vi write up.

I know. There's a big difference between peeking into something you're not supposed to, and interacting with a system designed to used interactively like that though.

Yea, I was really just trying to say, Acme is part of the Plan 9 ecosystem for people that have never heard of either. For me at least, Acme is the quintessential P9 application, but I concede that it's Sam for most P9ers in history. It's probably more apt to say Acme is an excellent exemplar of the Plan 9 way. The file-based socket-y proto-RPC "plugin" way of doing things is intimately tied to Plan 9's design.

And yea, Acme is different, but Sam is weird. In a good way though. I never really tried to get the hang of it, but Sam does live on in some ways (Vim Ex commands and such).

I'm also not surprised that a 9front user thinks it's a good idea to be weird. Just look at your webpage and this very bizarre thing that is for some reason linked one click away on the side menu: http://9front.org/movies/

I have been using Emacs as my daily driver for about a decade. It's the closest thing we have to a "popular" Smalltalk environment. The desire to bring everything into Emacs is the same desire I felt after experiencing what computing could be in Smalltalk.

One of the really striking things that you're confronted with in a modern Smalltalk is the Morphic UI system. Imagine that, with one click, you could drop into a new window with a live inspector and a (very freeform, repl-ish that's not a repl) REPL loaded into the internal context of any button, window, pane, scrollbar, you name it that you can see right now. (Even my own vocabulary is stifled with the traditional UI/UX we have now!) Now imagine you can do that on any application on your computer. Now imagine you can drag those subcomponents around, rearrange them, drag them onto new windows, modify their code, spawn new ones, and so on all while the thing keeps running and functioning.

If you break something, it's okay. The debugger pops up and allows you to do the same thing that you did when you inspected the widget for any point in the frame in the stack trace. Yes, you can debug, live, multiple levels of your stack trace at the same time, that have live, editable versions of the code as well.

You don't have to imagine it. You can see it here [1] or just download a Smalltalk system yourself.

If the Smalltalk community focused on building some tooling to allow you do develop other languages inside a Smalltalk image based editor, I don't think even Emacs could compete.

---------------------------------------------------------------------

As far as what kinds of weird would be fun, I always find new interaction paradigms fun. That's one of the things I loved the most about Acme. It's kind of crazy how versatile and adaptable "execute the highlighted text in the shell" is as a core interaction loop. If you want to search files for something, just type `grep` in front of the word, select them all, and then you get a new buffer with the results. Which are, of course, editable and executable in the same way.

The two most common places I see experimentation in this are in Linux window managers and programming languages. I've tried StumpWM, i3, and AwesomeWM before. I wish there were more people experimenting with non-tiling things. The person behind this project is doing some very cool stuff [2].

There are tons of people making cool, small (and large) new programming languages like Idris, Janet, Lean, and Pony and lots of people still using really cool old programming languages like APL (or J or K or BQN), Forth, and Scheme (Racket is great, Gerbil built on Gambit is insanely good for a one person project). I see some insanely cool stuff about prototype languages doing staged metaprogramming (lookup Collapsing Towers of Interpreters if you want to read about something really cool, i.e. compiling out the costly abstractions in infinite towers of reflective interpreters), dependently typed experiments, and other wild shit.

Surprisingly, there seems to be a lot (sadly meaning only 2-3 actually separate movements) going on in the "OS space" too with immutable/declarative system specification. I'm referring of course to Nix and Guix and things like Fedora Silverblue and OpenSUSE MicroOS. That's gaining steam quickly. I personally find the Nix language rather fun and interesting in its own right, but I think I'm on the minority side of that.

Broadening out past that, hell I don't know. That's why I put the call out to everyone else :D

[1] https://youtu.be/QTJRwKOFddc [2] https://codeberg.org/mmontone/mold-desktop

After a brief diversion with the Acme editor (a big part of Plan 9) and some modern Smalltalk environments (Squeak, Cuis, and Pharo), I can't help but feel like we are stuck in a very local optimum as far as UI/UX go.

The insane amount of introspection available to you in a Smalltalk image, and the way every bit of text becomes a potential button or action in Acme just put the lack of creativity in modern interfaces. I say all this as a Haskell and Nix fan as well, so I'm very in-tune to the benefits of functional purity and reproducibility in a computing system. It really makes the silo-ed world of isolated microservices, containers, and walled "garden" ecosystems seem really sad.

I guess this is my way of saying, that we should all try to do things differently. Haskellers, go learn Smalltalk. It's not a big deal that things mutate things when you can literally inspect every object as its running, including the debugger :D. Smalltalkers (or Rubyists or whatever is closest) go learn Haskell. Sometimes boundaries are GOOD. Formality can be very helpful when it comes to organizing, designing, and reasoning about your stuff!

And we should all try to do something weird.

What do you want to know?

I was going to mention the (at least) three different kinds of OO-y systems in R, but you already did. I think the reason that it's so hard for people to grok is that it's so old that a lot of code already exists, and a lot of that code is still used today!

Many libraries use different implementations of the same ideas for different things. It can be hard to handle if you're someone who likes to understand the whole system.

R is a fascinating language in its own right though. I'm not aware of many languages that give you first class control over environments as well or as easily as R. It can definitely enable some "lisp curse"-type code though.

R more than any language (even Scheme) lives the "build a DSL for your problem" dream that so many of us like from more standard languages. Consider the various ways to specify formulae for models; the very different ways to specify graphics in the base, GGPlot, and lattice libraries; and the various ways to to describe data transformations via the base functionality, the Tidyverse, the Tidyverse + Purrr, and data.table.

> God Emperor of Dune

I feel this way about Dune Messiah, except I didn't appreciate it until after Children of Dune. Dune is one of my favorite books, if not my favorite. Dune Messiah is a *frustrating* read right after Dune. It's not until you see the whole story of the first three books as one narrative arc that it becomes enjoyable.

I used to think like this until I actually spent some time with the modern things after learning a lot of the historical development paths. A lot of research is stitching together disparate ideas that have developed in their own little community silos. The best skills you can learn as a researcher are to appreciate, recognize (non-surface level) similarities between, and how to synthesize existing research.

There's an awful lot of cult of the new that goes on in modern research.

It's definitely why TeX macros are not "\long" (i.e. they cannot span more than one paragraph) by default.

Yea, I have been learning C recently too. I have found the experience quite a lot more enjoyable than I thought I would. I was originally motivated so that I wouldn't be "scared" to involve myself in working with C FFI calls in the various other languages I use.

I've found it just as much fun as Scheme, my favorite language to work in. If you think of Scheme as the minimum-usable implementation of lambda calculus, then C is like the minimum-usable implementation of a Turing machine. They're kind of dual to one another in a very fun way.

The one thing I'm really struggling with, like you, is understanding the C "ecosystem". Anything past Makefiles is so complex, especially for my uses. Using something header-only library like STB or a simple library like Raylib is super straightforward, but figuring out what, when, and how to use things like pkg-config, Cmake, Meson, or other tools is a real headache. Does anyone have any favorite resources?

I'd also appreciate something more detailed about modern C style, when and why I'd need a custom allocator, or anything else you wouldn't see in K&R or other introduction.

PS A lot of people say things like "libc" sucks, you shouldn't be using XYZ function from libc. What should I be using instead? I'm all for learning via implementing things myself, but surely that's not the recommended route for everything in C world.

OpenSUSE MicroOS is basically built around the idea of an "immutable" (read disincentivized to change) core while the majority of user space runs in a Podman container.

It was originally developed as an absolute minimal distro for running containers on servers, but the immutable desktop movement led them to develop a desktop user-facing variant.

Other ideas that are very similar: Fedora SilverBlue (very similar, more mature) and VanillaOS (based on Flatpak insteak of Podman/Docker, very new)

> Disclaimer: This post was written by A.I. using the prompt: "Write an essay in a sarcastic tone that argues why personal knowledge management is a fad."

I thought for sure that this was just a hot take punctuated by another hot take. Well, damn. I put the same prompt into ChatGPT, and it spit out the exact same text.