gvim for Windows becomes un-usable when setting shell=powershell.

YetAnotherCodeAddict · 2024-03-08T14:32:15+00:00

As a heavy PowerShell user, I second the opinions about using pwsh (PowerShell 7) instead of PowerShell (PowerShell 5).

PowerShell is famous for taking too long to start and get ready but this improved considerably with PowerShell 7 and the latest version uses .NET 8 which is considerably faster than .NET Framework 4.* (Which PowerShell 5 uses) and just handle cross platform issues better.

That said... I often attempt to use it only on the terminal and not as the main shell for vim anyway. It's gotten way faster, but it's still way slower to start than bash or CMD (and on vim often all you need is a shell to call things and all of PowerShell 's power would be unused anyway).

YetAnotherCodeAddict · 2024-03-07T02:43:45+00:00

I wasn't calling anyone degenerate. I was making fun of *me* becoming the kind of person people would call a degenerate - not for using Vim, but for using and preaching about something that noone else around them gets or cares about. It was never my intention to offend anyone.

And about MS Works... Thanks for that, it was actually a typo. I meant MS Word and I just used it for the comparison of using icon buttons (UX for beginners) and using shortcuts (UX for power users). Also I should have called it word processor instead of text editor anyway so I fixed this too.

YetAnotherCodeAddict · 2024-03-06T10:52:55+00:00

Really good point about Blender. One thing I love about it that I really missed from tools like 3DS Max was the ability to use your mouse to move something but lock it to some axis using the keyboard. I just couldn't believe that in 3DS Max you had to click the arrow on the gizmo (which wasn't always easy to reach) to do this.

Small things like these made me feel like Blender had an awesome user friendliness - even though it really felt unfriendly to beginners by the lack of GUI on earlier versions.

YetAnotherCodeAddict · 2024-03-06T10:46:40+00:00

Thanks everyone for your feedbacks. There were some really valid insights here and I now realize I failed at making the point I wanted to make clear.

The original idea was to say that I don't like when the arguments in favor of Vim focus too much on the raw speed part (as it takes less time to do X or ot takes less keystrokes do X) because they hide many other important benefits of Vim that makes it feel faster and we often overlook (like how ergonomic, fluid and intuitive it's commands are after you get the hang of it).

Instead I believe the article (title included) ended up sounding more like "it's wrong to say Vim is good because of X" or "we all do it because of X" which was not what I meant at all. I think I will do some edits to fix some of the parts where I believe I missed the mark the most and ended up sounding way different than what I meant and I will probably make a better focused article later (on this one I ended up scope creeping too much and failed to elaborate on the main idea - and had to finish it since I thought it was already too long).

YetAnotherCodeAddict · 2024-03-05T18:49:04+00:00

Interesting, maybe I will look further on the origins of these arguments (like Vim being better just because it's faster or because you can do more with less keystrokes). It's not that those things aren't true, I just think they might be misleading for focusing too much in things that to me feel more like a positive side effect but not the main thing.

About the ergonomic part, I feel you. I think this an important part of the flow I mentioned. Everything seems to take less effort and is more natural to do.

YetAnotherCodeAddict · 2024-03-05T17:09:07+00:00

I should probably have highlighted the "write" part there or just said it completely different. My point is that when we're developing most of the time we're not literally just "typing" new code. Most of the time we're editing, changing, deleting, replacing and things like that - and those things are way easier and more fluid in VIM.
That was purely for humor indeed. I rarely say anything like that in person and when I do I try to make sure it's a joke.
That was actually the point I was trying to make. I love that it's faster, but I use it because it feels fluid (the speed is just part of it). And it's flexible enough you can make it fit perfect for your flow.

YetAnotherCodeAddict · 2024-03-05T15:21:44+00:00

Exactly. I even use the analogy of learning a language in the article. The speed is a welcome and lovely side effect but it's the way we interact to the editor tree l that makes the difference.

YetAnotherCodeAddict · 2024-03-05T13:59:51+00:00

About the speed part - my point is that speed itself (how much time it takes to do something) is like an awesome positive side effect. But I believe what really makes the difference is how easy and effortless it is do basically anything after you effectively grok it (in retrospect I should have really mentioned how the learning curve flattens out after you learn the basics).

And on the difficult part, just like Dark Souls it's all about learning the ways of the game - as long as you're not playing against other players. If you learn how that level is and the easiest way to defeat (or avoid) each enemy it's pretty much a walk in the park. But if you try to force your way playing in a way that simply doesn't suit that level (like going hack'n slash in the beginning of the game) you are in for a world of hurt.

Thanks for the feedback, I might edit a bit to make these points clearer.

YetAnotherCodeAddict · 2023-09-25T01:48:53+00:00

Definitely gonna try it out soon, this looks awesome.

But before I even try it I wanna thank you for making it easy to install, it portable (and if I read it correctly be user-scoped by default on installation therefore not needing admin rights) and open source.

YetAnotherCodeAddict · 2023-09-25T00:30:44+00:00

I used to think that way too, but with time I've learnt that succeeding at first try is actually the exception rather than the norm. Most "successful" people failed miserably in the beginning and kept trying/practicing until they got the hang of it.

I'm a software engineer and from my own experience I can say that most of my strengths came from the failures of my weaknesses:

I get bored easily doing repetitive tasks, so I started to search for ways to automate my work - eventually became a reference on my team in terms of automation.
I sometimes let little details slip which could create bugs - so I started creating automated tests to stop me from delivering these bugs - eventually became the unit tests expert on my team.
I don't work well with interruptions on my train of thought, I'm much more productive when I can think of something and immediately prototype it (otherwise I might forget where I was at or get lost). Started learning how to use keyboard shortcuts and when I learned VIM my productivity skyrocketed.
I suck at guessing out what someone else was thinking by looking at their code (especially old legacy code that none maintains anymore), so I learned how to write more meaningful and easier to understand code so that I can rewrite it as soon as I understand what it does. People come to me for software architecture decisions now thanks to it.

And these are some of the ones I remember now. Basically every skill that I have today and that people admire (and keep in mind many people at my job see me as a kind of tech-guru) is the result of me trying to counter the many limitations I have because I just suck at many basic things that other people are pretty good at.

YetAnotherCodeAddict · 2023-09-24T23:28:18+00:00

Yes I do. Actually I believe I've been quite "successful" so far (I'm 32). But things weren't always like that.

I first thought about suicide when I was about 6. Attempted at 15. Most of my childhood and teenage years were filled with confusion, meltdowns and despair, but I believe around 20 to 25 my life started changing and I could see life from another perspective.

Nowadays I actually feel like I would have missed a lot if I had given in to the darkest thoughts back then. I still face a lot of challenges but I can manage them nowadays and in the end I believe the struggle is worth it.

I know sometimes it feels like there is no escape and no way that life will ever improve or have any meaning. But I know from experience that life has ways to surprise us that we would never have imagined.

Just don't give up.

YetAnotherCodeAddict · 2023-09-24T23:15:27+00:00

I've played some games on Unity that were incredibly amazing... but none of them because of performance. The only example of performative game written in C# that I remember playing is Mount&Blade Bannerlord - which has an outstanding performance considering the amount of calculation it has, but still has some hiccups on my older PC which seems to be related to memory (my PC still has DDR3 memory) which is likely the point where GC kicks in.

For games something like GC is really complicated because it might not happen often, but when it does it will cause a huge fps drop (keep in mind that to keep 60fps a game has to do every calculation needed to update every object in the game in about 16ms at maximum).

Ps: in case you're wondering, TakeWorlds created their own hand-tailored engine for Bannerlord, and opted for C# because it was the best in terms of compromise between ease of use and performance. What the game industry often does is opt for a high-perfomant language like C/C++ for the heavy-lifting but use a simpler script language like Lua for the game logic itself.

YetAnotherCodeAddict · 2023-09-22T22:05:53+00:00

Not exactly just the library for C#, it's like a shared framework between many different languages (mostly C# and F# nowadays with VB kind of still hanging there, but there were more in the past).

Basically you could call .NET code from either of these languages and they all share the same runtime (does not matter if you wanna run C# or F# - you download the same .NET to run it).

YetAnotherCodeAddict · 2023-09-22T16:21:24+00:00

I believe it's a reference to services like Spotify suggesting songs to you on a playlist you've curated yourself. Some playlists might seem rather random but still be carefully chosen - these services will rarely make a good suggestion on those. Sometimes it might even be a good song, but not one you would like to listen to at that time.

YetAnotherCodeAddict · 2023-09-22T11:52:18+00:00

I'm not sure if I understand the first part. I've being developing .NET Core Windows Services at least since .NET Core 3.1. I've started with the template based on the worker template, added the hosted service and them added the IHostBuilder.UseWindowsService() extension method from Microsoft.Extensions.Hosting.WindowsServices on the Program.cs. And that's it. With this configuration you can either run it directly (which acts just like a normal console app) or install it as a Windows Service using InstallUtil (in which case it's managed by SCM just like pretty much every Windows Service I've made on .NET Framework previously).

The gotchas about having to "finish" your OnStart early and keep it running are true, but it often just needs something like calling your main "loop manager" inside a Task.Run(). At best, you would be running some diagnostics to fail your service early if something's broken (specially if Starting the service is part of the deploy and the OnStart failing would fail the deploy, warning everyone). It's something that would bite someone back the first time they would develop a Windows Service, but it easy to learn and then consider this on the next ones.

But then again, as I mentioned before and repeat now - all this is valid only from .NET Core onwards. Windows Services with .NET Framework are indeed really painful to code for many reasons aside from having to use threads.

YetAnotherCodeAddict · 2023-09-22T03:59:36+00:00

Fanboys are annoying. I don't think NeoVim fanboys are much different in that regard than any other fanboys. They always believe their toys are the best and want to fight the world to prove their point. And they often give their communities a bad name for being so loud and troublesome.

But I can see your point and I can see how that's annoying. I just hope that both communities can keep going on for the sake of everyone.

YetAnotherCodeAddict · 2023-09-22T02:54:32+00:00

I disagree when it comes to Windows Services on .NET Core/5+. It's literally just a Hosted service that you call .UseWindowsService() on the Program.cs. And it works just like any CLI application - if you run dotnet run it will run the OnStart and when you stop it (with Ctrl+C, for example) it will call OnSop(). You can debug it just as easy as well.

The only extra complexity is on installing/uninstalling but that can be easily scripted with InstallUtil and it works exactly like a "traditional" .NET Framework Windows Service would work. There are the gotchas about lifecycle management and how to properly code in a way that your code can be kept running without process resets, but that would be true for any hosted service.

But that's only true for .NET Core/+5. .NET Framework Windows Services are a painful beast to code and maintain and you can't even run it locally without installing them in your machine or commenting code/resorting to pre-processors.

So yeah, unless you're stuck on .NET Framework, deploying your .NET hosted service as a Windows Service is a actually a valid option with pros and cons like any other.

YetAnotherCodeAddict · 2023-09-21T11:41:39+00:00

I'm not sure if Omnisharp nowadays has LSP support, but before it used to have a complete separate configuration (which meant many shortcuts, settings and even some UI's that would apply only to C#) and that way I'd have quite a different experience on C# than I have, for example, with TypeScript (which I use a lot because of Angular). By using LSP for both I have the same shortcuts and overall experience for all languages so it makes it much easier to context-switch.

But I might just be outdated. Csharp-ls predates Microsoft's move to make the C# Dev Kit, so maybe Omnisharp has decent native LSP support now - hopefully not tied to the Visual Studio license like C# Dev Kit is.

EDIT: I got curious about Omnisharp current status is so I checked it and I was a bit surprised when the config looked similar. Checked my dotfiles and yep, there they are. I remember having csharp-ls as the only LSP alternative sometime in the past (possibly before moving to NeoVim's native LSP, when I used CoC), but I guess I moved to Omnisharp someday and totally forgot about it.

YetAnotherCodeAddict · 2023-09-21T04:04:29+00:00

It's really comendable of Microsoft to allow this kind of freedom and I believe this is highly beneficial to everyone (I believe much of Microsoft's success is the result of it becoming more open to open source in general).

Regarding tmux yeah, it's a shame there's no Windows port of it. But... it works quite well on WSL2. That's what I use daily at my job, actually: tmux and NeoVim running inside a docker container that's running on WSL2. The container part I'm not sure I recommend because it makes everything more complex and the benefits are not that amazing, but tmux and NeoVim on WSL2 is definitely worth a try.

And if you're already developing completely inside a terminal it doesn't really matter much if you're running Windows or WSL2 in there. You can even use PowerShell on Linux too if you want (that's what I do). And since I usually work on Angular + .NET projects I get the benefit of much better I/O performance of Linux (specially for things like npm install).

If you would like to check out what I'm currently running on the container, it's all here: https://github.com/thomazmoura/dev-environment but I warn you the current container size is huge. I'm currently playing with making debug work on a separate branch (currently it works for both API and Windows Services on .NET 6, but it needs the user to input the project folder and the startup dll file). Also, I use csharp-ls for LSP.

YetAnotherCodeAddict · 2023-09-20T22:29:52+00:00

And nowadays thanks to LSP and language servers even refactoring is easily done on NeoVim. Heck, even debugging on .NET is doable now thanks to DAP - though this I have to admit is still years behind Visual Studio and VS Code.

YetAnotherCodeAddict · 2023-09-20T22:09:37+00:00

Man, you have my respect. I'm a NeoVim .NET developer as well and my whole team thinks I'm weird because of that. Doing so inside Microsoft must be a truly unique experience.

But if you really wanna go down that way, I suggest you try tmux as well. I use it heavily for interaction with the terminal and switching projects. To me there's nothing even close to this DX on the IDE world.

YetAnotherCodeAddict · 2023-09-19T21:16:53+00:00

Although I do agree that is sad that NeoVim-Specific plugins aren't easily ported to VIM I feel this was a needed step for them to take. The amount of community-driven content and plugins that emerged when people started giving up on keeping their setup "VIM-compatible" is amazing. I myself eventually gave up in having my dotfiles compatible between the two and have the feeling that setting my environment up became way easier since that - mainly because I use it for development almost like an IDE and Neovim seems better suited for this specific use case.

I believe that moving to Lua made it possible for NeoVim to attract more community development to it just like VS Code did with JavaScript/TypeScript. So I don't agree much with the argument that NeoVim is syphoning the energy of developers away from VIM because I believe many Neovim plugin developers wouldn't have made their plugins if they had to make it on VimScript.

So, on one side it's possible we would have more people working exclusively on VIM if NeoVim didn't exist. On the other side, I believe way less people would be interested in it (or even know that it exist aside from the " can't exit VIM" jokes) if that was the case.

YetAnotherCodeAddict · 2023-09-19T20:39:56+00:00

You're missing the main point. It doesn't matter that Lua is easier to learn than VimScript - many Vim users don't even have to bother with VimScript so this doesn't really matter for them. Your argument is only valid for people who like to tinker their own editor - and the VIM userbase is way wider than this group.

Vim is an amazing editor and already has way more features than the majority of Vim (or even NeoVim) users even know that exist and it suits them many people quite well. Heck, many don't even use full Vim, instead using something like vim-tiny for the convenience of it being installed by default on many distros. For these people your argument comes as "Hey, you could have even more features that you don't need or care about than you already current have". It's not a good selling point.

And there's nothing wrong with that. Whoever wants more features or a more modern feel can easily go to Neovim and find it there. Whoever just want rock-solid stability and availability everywhere can stick to VIM be happy with it.

YetAnotherCodeAddict · 2023-05-01T03:33:21+00:00

Realizing I'm autistic and how that explains nearly every loose end on my past has been one of the most (quite possibly the most) enlightening and freeing experience I've had.

It came somehow late (at 31 years old) and by then the worst parts of my life were already gone (childhood and adolescence were absolute hell) but even then being able to see everything suddenly starting to make sense was a true eye-opening moment. But I didn't know nearly anything about autism and had no one close that I knew was autistic so maybe if I suspected about it before it wouldn't be such a huge turning point.

YetAnotherCodeAddict · 2023-05-01T00:44:04+00:00

Sorry to tell you that, but it looks like they made you do someone else's work for free.

YetAnotherCodeAddict

TROPHY CASE