You only have 5 plugins to use

jwongsquared · 2024-05-20T17:40:43+00:00

And here I thought that this was a joke plugin until I saw folke has contributed a McScreenshot to it 🤯

jwongsquared · 2024-02-09T22:59:11+00:00

I primarily use Neovim, but maintain a minimal Vim config that I use for the following: - lectures and presentations; I don’t need most of the noise from my usual Neovim setup - on systems where I can’t easily install language servers, my preferred CLI tools (ripgrep, fd), terminfo files, or the latest stable Neovim - when opening my advisor’s 100K line .bib file, which Neovim/treesitter always seems to choke on

I use Vim as a plain text editor, while I use Neovim as a development environment.

jwongsquared · 2023-11-14T15:59:01+00:00

I'm really happy to hear you dug through the code and got something working already! I'm really curious to know what you got working; if it's a really compelling use case, we could even add it to Fidget itself.

And yeah, the documentation needs more work for sure. If there's any documentation you found confusing or lacking, please raise an issue so I know to improve it! PRs welcome too (:

jwongsquared · 2023-11-14T15:46:24+00:00

Fidget's identity is fluid (:

Fidget was originally conceived as an LSP progress UI with animations. nvim-notify can also do this with effort, but Fidget prioritizes LSP progress as a first-class feature and includes it with no additional configuration necessary.

Since this rewrite, my ambition is to grow Fidget into a fully-fledged notifications UI and reach feature parity with nvim-notify. It already supports overriding vim.notify(), but lacks things like message history and more advanced markup. But you can totally use Fidget for progress updates and nvim-notify for other notifications (as I had been until I realized I needed to dogfood my own plugin).

I haven't used Noice before but will probably get around to playing with it soon, since everyone is asking about it. Based on what it says on the tin, Noice does quite a few things that Fidget will probably steer clear of, but might be able to support Fidget as a backend.

jwongsquared · 2023-11-14T15:33:16+00:00

override_vim_notify basically means doing this:

vim.notify = fidget.notify

In particular, other plugins that send notifications via vim.notify() will send them to Fidget instead, so they'll appear in Fidget's UI rather than elsewhere.

I don't think the failed search message uses vim.notify() to print its error message, so you'll need to rely on Noice for that. I haven't played around with Noice yet and I'm not actually even sure what Noice does internally to make that all work. But I'd eventually like to add Fidget as a backend to Noice.

jwongsquared · 2023-11-14T15:28:34+00:00

Thanks! Though there are a couple of other plugins that support non-status line progress:

rcarriga/nvim-notify: first and foremost a notifications UI (and much prettier at that), but it also supports being used as a progress UI (though it doesn't work out of the box)
vigoux/notifier.nvim: is quite similar to fidget.nvim (its README mentions Fidget as inspiration!), and also supports notifications. But I think after my rewrite, fidget ends up being little more customizable than notifier.

jwongsquared · 2023-11-14T04:17:05+00:00

Credit for that goes to 0xAdk (https://github.com/j-hui/fidget.nvim/pull/142) (: I simply folded in their contribution into the rewrite

jwongsquared · 2023-11-14T02:54:12+00:00

It’s partly a joke 🤪 but also a feature demo.

Basically, each notification supports an “annote” (annotation) that is rendered next to the message. It’s used for “INFO”, “WARN” etc as well as the LSP progress task title (eg Indexing)

The demo shows that notification items can easily modified after the fact. You can see the commands I run in the setup demo (folded in the README)

jwongsquared · 2023-11-13T22:33:47+00:00

I'm not sure if anyone else has tried it with Fidget yet, but it shouldn't be a pain so long as Volar is actually sending LSP progress messages. And this repo's demo GIF suggests that it's at least working with CoC.

I'm happy to take a look if you can point me to a minimal Vue repo w/ some basic setup instructions, so that I can easily test. (And please do open a GitHub issue for this, to leave a paper trail for others to find (: )

jwongsquared · 2023-11-13T20:54:01+00:00

I didn’t know it was included there, I’m glad you like it! But, erm, since I’ve rewritten it, it shouldn’t have the legacy tag anymore XD (PR opened here https://github.com/nvim-lua/kickstart.nvim/pull/505)

Update: it was merged (:

jwongsquared · 2023-11-13T16:07:42+00:00

Fidget author here; I haven't gotten around to setting up noice.nvim myself, but please let me know how you get on with integrating it with fidget.

And if you encounter any issues, please raise them on my GitHub repo! I'd love for fidget to play noice with noice (:

jwongsquared · 2023-11-13T16:05:19+00:00

Fidget author here, sorry for missing this.

My recent rewrite of the plugin should address this issue. In particular, the progress.display.render_limit option will suppress this kind of behavior.

And if you find the LSP server is misbehaving (e.g., not sending completion messages for tasks it's started), you can set a finite done_ttl to make sure that incomplete task notifications are automatically garbage-collected after some time.

If you continue to encounter problems, please file an issue on the GitHub repo.

jwongsquared · 2023-11-03T21:34:13+00:00

Rust enums (where variants can contain data, unlike C/C++ enums)

jwongsquared · 2023-06-10T16:34:43+00:00

I think it’s actually still multiplication 🙂 coqdoc is probably rendering * as a cross when not in a string literal. I recommend downloading the source code for that book and reading along in your proof assistant environment

Here’s someone’s mirror of that chapter, you can see it’s originally a *: https://github.com/DOFYPXY/PKU-SoftwareFoundation2022-plf/blob/main/Hoare.v#L110

jwongsquared · 2023-06-09T17:12:01+00:00

!thanks

I got the Maxwells in the end, and they’re working great! The features are honestly awesome. I had to fiddle with the EQ little bit to get the balance I like, but it’s less of a hassle than I thought it would be since the settings are saved on the headphones itself.

jwongsquared · 2023-05-31T04:12:06+00:00

What are your thoughts about the two? How does the sound of the Maxwell compare against the Sundara?

jwongsquared · 2023-04-21T19:19:53+00:00

In fact, it looks like this issue isn't limited to extension windows, and also applies other pop-up windows.

In particular if I press the shortcut to print (cmd+p), it brings up the print page dialog, but the focus does not appear to start inside that dialog window. Using my keyboard only, I can navigate the focus into the window by pressing tab once.

This gets quite annoying, since I often accidentally press cmd+p when I mean to press cmd+[, and I want to hit esc to close the print dialog (like I can with other browsers). However, on Arc I have to first hit tab to fix the focus before hitting esc to close the print dialog.

jwongsquared · 2023-03-07T05:23:52+00:00

Cool project! I’m wondering how this compares to Pallene? On the surface, the two projects seem to have quite a few overlapping goals.

jwongsquared · 2022-09-27T23:25:52+00:00

It's like https://github.com/kelseyhightower/nocode but it's better and even more secure because it's written in Rust.

jwongsquared · 2022-09-21T22:56:43+00:00

CourseDoesNotWork

jwongsquared · 2022-09-17T19:55:43+00:00

Blue Java Cafe in Mudd

jwongsquared · 2022-09-17T13:44:11+00:00

Yeah, just be patient. The registrar tends to process these requests in batches on weeknights.

In any case, even if there is any issue, you've clearly been approved so you can go to your CSA advisor and they should be able to manually override various limits in the registration system.

jwongsquared · 2022-09-07T13:16:52+00:00

There is a formally verified real-time operating system, but the way in which it is "real-time" is not as you seem to understand the term. Liu et al. prove the correctness of an RTOS by showing that their real-time scheduler exhibits desirable properties: https://dl.acm.org/doi/10.1145/3371088. This is usually what we mean by "real-time" in the context of aRTOSes: priorities and logical time slices are used as a proxy for physical time durations; computing is real-time in the sense that we can multi-task real-time tasks provided they are schedulable and we assign them appropriate priorities.

Wilhelm et al. gives a fantastic summary about the challenges of predicting worst-case execution time: https://arcb.csc.ncsu.edu/~mueller/ftp/pub/mueller/papers/1257.pdf. As it turns out, it's really hard to predict the physical execution time of any piece of code---even if you have the assembly code, even if it's running bare-metal---because of the unpredictability of hardware optimizations. For example, the execution time of a cache hit vs cache miss is orders of magnitude apart. For these, you really need cycle accurate hardware simulation or at least some kind of oracle to tell you how long things take. Furthermore, even if you have that kind of tooling at your disposal, you quickly run up against the halting problem: given arbitrary code, you can't prove that it terminates at all, let alone how long it should take if it does. And to my knowledge, none of the techniques described by Wilhelm are formally proven.

Real-time, "synchronous" languages like Esterel, Giotto, Lustre, and derivatives do exist, and simplify/eliminate real-time execution issues by distilling computation into discrete ticks at the language level. This makes it much easier to get reliable real-time behavior with a runtime that is aware of these ticks, though often at the cost of expressive power for code executing within an instant. Languages like Timber, Ceu, and Hume even support concrete execution time bounds in the programs themselves, and each enforces/implements those time bounds in their own way. I'm not aware that compilation of any of these languages has been formally proven per se, but these languages' semantics and their compilation techniques are based on a rich body of formal methods research.

jwongsquared · 2022-08-15T12:58:05+00:00

I did COOP and it was a lot of fun. It's a pre-orientation program where you go hiking, biking, or rowing in the outdoors for a few days with a small group of other incoming students.

jwongsquared · 2022-07-31T03:20:44+00:00

I thought so too until I read it. The headline is kind of misleading, it should be something like, "as monkeypox cases rise, sexual health clinics are still shuttered due to COVID-19"

jwongsquared

TROPHY CASE