priomsrb

One example could be something that's a list of files/folders e.g. .gitignore

Or it could be a list of records:

{name: 'Alice', age: 42}

{name: 'Bob': age: 44}

Looks nice!

It would be great if you had a simple website that allowed you to enter SOML and see the JSON side-by-side (similar to typescript playground https://www.typescriptlang.org/play/).

I use my M1 pro to play Dota 2 all the time. On medium settings I get between 60-100fps at 1440p.

I probably game on it more than my gaming PC and consoles at this point.

I was of the impression that Tesla's self driving is still not fully reliable yet. For example a recent video shows a famous youtuber having to take manual control 3 times in a 20 min drive to work [0]. He mentioned how stressful it was compared to normal driving as well.

[0] https://www.youtube.com/watch?v=9nF0K2nJ7N8

Fair point. Though the 7ms I mentioned is broken down into:

- 5ms network latency

- 2ms display latency (includes decoding + vsync latency)

I'm assuming that the mouse/keyboard can begin processing as soon as the network call is done. If true that's about 5ms.

Keep in mind that different mice vary in their latency. Even wired mice can vary from 1.5ms to more than 25ms in click latency [1]. So if you use a low latency mouse over the network, it could be faster than some mice that are plugged in directly.

[1] - https://www.rtings.com/mouse/tests/control/latency

On fast paced games that run at 100+ fps, I don't really notice it being missing. But in games that have high graphics, and lower FPS, it's noticeable.

For my setup, I do a "local" version of Geforce Now.

I have my gaming PC in another room and stream it to my laptop using Nvidia's GameStream and Moonlight. I run it at 1440p with 120fps. With everything connected via ethernet, I get an end-to-end latency of 7ms. This means my stream is only just 1 frame behind the PC.

I use this setup for fast-paced games as well as regular PC usage. 99% of the time, I can't tell that it's a remote stream.

The advantages of the setup are:

1. Don't have to deal with the heat and noise of my gaming PC being in my room.

2. Switching between my laptop and gaming PC is faster than using a hardware KVM switch.

3. I can easily stream games or use my PC remotely with tablets and phones.

Disadvantages are:

1. Gamestream and Moonlight don't support streaming dual screens at once.

2. Gsync doesn't work over streaming. So lower frame rates (< 60fps) aren't as smooth as native.

Not sure what you mean. I use a 3440x1440 display with 118% global scaling using KDE.

If Xbox game pass is available for you, you can also get it for free with a $5 monthly membership.

Ugliness aside, there are some things that don't work very well in a plain spreadsheet vs a UI. For example large paragraphs and images.

Part of conveying information should be about making the information easy to digest. Sometimes a spreadsheet fits that bill. Other times a crafted UI works better.

I started using org mode with doom Emacs. As an Emacs novice it was pretty easy to set up and came with some nice defaults for org mode.

No need for elitism. I'm sure there are scientists and researchers perfectly happy with Notepad++ and I've worked with web developers who've used emacs.

I agree that VSCode is unlikely to reach the level of emacs in terms of being a fully programmable environment. But what it does offer is an easy and modern out-of-the-box experience.

You shouldn't need promise chains nowadays since async/await is available. Also, I'd be interested to see 200 lines of idiomatic JS being written in 10 lines of idiomatic Python, PHP or Ruby if you have an example.

I use vimswitch (http://vimswitch.org) to copy my vim settings over to new machines.

(Disclaimer: I am the author of vimswitch)

If you find it annoying/difficult to pull in your vim config you may find VimSwitch (http://vimswitch.org) helpful. For example, when I start using a new machine I type:

  wget https://bit.ly/vimswitch && chmod +x vimswitch
  ./vimswitch priomsrb

This gives me my vim config along with all my plugins.

Disclaimer: I am the developer of VimSwitch

I wonder if the end result could be fed into a compression algorithm. The algorithm would need to have a low data overhead as the snapshot sizes are around 32 kilobytes (256 kilo bits).

It would be interesting to know what compression algorithms work well for this kind of application. One example I can think of is Run Length Encoding. Or perhaps an algorithm that is trained on example datasets and finds bit patterns that repeat often.

No, it does not run :BundleInstall for you. Maybe it would be a good idea if the user could specify some commands to run after downloading a profile. For example they could add a line in their .vimrc:

    " vimswitch-after-download=:BundleInstall

Ahh. Thank you for reminding me. It's been added now.

It should work with both as VimSwitch recursively copies ~/.vim. I'm using Vundle for my own profile without problems.

That's a good point. My example comes from experiences where the only available users are 'admin' or 'logs'.

OP here. VimSwitch does something similar to what your script does. It just makes it a bit more convenient. Here is a use case that I plan to use it for:

    # log into production server
    $ vimswitch priomsrb/vimrc
    # -- work --
    $ vimswitch default
    $ logout

This puts vim back into it's original state for the next person who logs in.

In future versions I hope to make the above workflow even simpler:

    # log in to production server
    $ vimswitch --launch priomsrb/vimrc
    # log out

The --launch command will launch vim with your settings without altering the home directory.

Makes sense. But 64k of data seems oddly large just to ID a message.

I like to use eclipse with the vrapper plugin. That way I get the completion and refactoring of eclipse as well a decent set vim key bindings. Vrapper may not perfectly emulate vi/vim but it does the basics well. And when I need to use advanced vim features (eg macro magic) I just open the file in vim.

To me the IDE features make up for the minor annoyances of using vi/vim emulation.

I think it would be cool to have a vi/vim engine that can be added onto editors. The editor would only have to overload simple functions like keyPressed(key), getChar(pos), setChar(pos, c), etc, and the engine would take care of the rest of the vi/vim emulation.

This approach would be better because there will be a single effort rather than each editor writing its own vi/vim mode. Also when a new feature is added to the engine it would be available on all editors.

RazorQt is a lightweight Qt desktop environment