All the "Thanks for watching!" gave me a good chuckle.
Remind me of one of my own experiences with one of the Whisper model, where some random noise in the middle of the conversation was translated into "Don't forget to like and subscribe".
Really illustrate where the training data is coming from.
First, the linear attention of RWKV leads to significant efficiency gains but still, it may also limit the model’s performance on tasks that require recalling minutiae information over very long contexts. This is due to the funneling of information through a single vector representation over many time steps, compared with the full information maintained by the quadratic attention of standard Transformers. In other words, the model’s recurrent architecture inherently limits its ability to “look back” at previous tokens, as opposed to traditional self-attention mechanisms. While learned time decay helps prevent the loss of information,it is mechanistically limited compared to full self-attention.
Hard disagree. Sometimes the terminal is the most efficient way to run Emacs on a machine in a remote data center that has a mountain of CPUs, GPUs, memory, and disk. TRAMP can be slow and inefficient. A LSP server process on a huge monorepo can chew up a large amount of memory and CPU on startup. Running all of this stuff locally on the actual hardware your code needs to run on is great.
TRAMP is great, but to me it never feels the same as running locally. OTOH ssh -X (i.e. X forwarding) works for me for exactly this specific case (large and powerful remote dev box).
Incidentally my current setup is that I'm WFH and RDP'ing into my windows desktop, where I run VNC to our xvnc server where I ssh -X to the dev box where I run GUI emacs. It is surprisingly usable (I can also skip the RDP and run VNC directly if needed).
I have been testing Emacs 28 for a few weeks now, as it was reported to improve performance on LSP integration (which was sometimes sluggish for me with rust).
I have to say I wasn't disappointed. It's now comparatively blazingly fast. I hugely recommend to give it a try if you work in emacs with LSP.
Since my distro had not packaged it yet, I installed it from guix instead (package `emacs-next`). It worked like a charm.
I tried installing a lsp package at some point, but I couldn't figure out if it was actually doing anything over and above the language major modes. Not sure if it was actually doing anything at all actually.
Sorry, to clarify: I used the package `emacs-next` from guix to install emacs 28. You still need to install and configure emacs-lsp along with the LSP backend(s) you want to use.
Thank you for that. I haven't really checked out any of these distros (doom, prelude, etc.), but maybe I should.
One of the issues I have is that I work on multiple disconnected servers, and so I usually end up installing emacs on all of them. Using tramp is an option, but often times I just want a local editor because I find myself needing one in the context I'm working in. But all the servers run slightly different OS versions, etc.
Maybe a mangaged-for-me distribution that does most everything I want without me fiddling with it is the way to go.
I track my config in a git repo, and doom-emacs is rather helpful on what external tools must be installed for various configuration "layers" (like when working with such and such language). When using LSP, it can even proposes to install an appropriate language server in some cases.
Don't think out of the box, but https://github.com/emacs-lsp/lsp-mode works rather well with emacs 28 from my experience. Emacs "distros" such as Spacemacs and Doomemacs both make using it a nearly "out of the box" experience.
(not supporting the editor/ide war troll, just trying to contribute some useful info here)
It is actually amazing, emacs is probably the best example of a "living" program you can modify interact and debug directly while you are coding it.
Obviously lisp has been designed around its REPL and debugging experience and the concept of "living programmable programs", but emacs reaches an insanely high level of business complexity, far higher than any software any of us probably writes at work and yet modifying and learning the very program you are using with the program itself is a 30+ years old solved problem that apparently ecosystems outside lisp dialects seem not to pick up.
Or that they used VC money to outcompete companies using artificially low prices, and then raised the prices to make some profit once they got a hold on the market
> you'd need to prevent the people you're granting the license to from changing it in derivative works
No you don't need to. People cannot change the license of code they don't own nilly-willy, only the owner(s) of code can (which can get hairy when a codebase has multiple owners).
However a license can allow sublicensing, aka sharing the code or software under a different license, but this right must be explicitly granted by the license (or by the code owner directly), and they may be conditions attached (such as attribution)
MIT:
"[...] Permission is hereby granted,[...] to use, copy, modify, merge, publish, distribute, sublicense, [...] subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software."
GPL:
"[...] You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License."
So the MIT license grants you the right to redistribute the code under GPL (under attribution condition), but GPL does not grant you the right to redistribute the code under MIT.
(Note that all of this applies to redistributing the code or the software, not about your own internal use of the code or the software)
Remind me of one of my own experiences with one of the Whisper model, where some random noise in the middle of the conversation was translated into "Don't forget to like and subscribe".
Really illustrate where the training data is coming from.