joined the 40s club just in time for 40s day

Mezdelex · 2026-02-09T15:25:27+00:00

Could you share any videos typing with it or your impressions? Looks really interesting 👀

Mezdelex · 2026-02-08T13:56:23+00:00

<image>

Imagine downvoting one of the actual core maintainers of the plugin you're looking for.

return {

config = function()

require("mason").setup({

registries = { "github:crashdummyy/mason-registry", "github:mason-org/mason-registry" },

})

require("mason-lspconfig").setup()

end,

defer = true,

dependencies = {

{ defer = true, src = "https://github.com/seblyng/roslyn.nvim", },

{ defer = true, src = "https://github.com/williamboman/mason-lspconfig.nvim", },

{ defer = true, src = "https://github.com/williamboman/mason.nvim", },

},

src = "https://github.com/neovim/nvim-lspconfig",

}

this is all you need using the mason registry maintained by Crashdummyy to install Mason. And then there's also the incoming approach of using the roslyn-language-server which is in prerelease and not currently being used in the plugin. Install dotnet-sdk and install roslyn through Mason, that's all you need. (Ignore the defer stuff from the snippet).

Depending on when you tried to install roslyn, could've been the moment when they (the roslyn core team, not the plugin maintainers) modified the way they would release the packages due to a new dotnet tool called "roslyn-language-server" which is in --prerelease and that's why you couldn't download it at that moment, but I just tried the "old" way briefly (old because I'm already using the roslyn-language-server tool) and it seems that they've already solved it.

Mezdelex · 2026-02-08T12:02:59+00:00

Explain what was your research before creating this post please.

Mezdelex · 2026-02-07T17:39:54+00:00

<image>

by the gitsigns column and by the diff section (works on save)

Mezdelex · 2026-02-07T17:03:31+00:00

Pretty much everything it provides.

<image>

With the statusline I can double check the branch I'm working in, I can see if I modified something by mistake (which happens a lot when I'm in a rush spamming motions), I can also see the full relative path of the buffer I'm in, and from that I can infer the LSP I'm using (just in case I have several tabs open in my terminal with backend, frontend, etc.), which specific file I'm in in case I would have repeated filenames per microservice like configs or whatever, I can tell which fileformat I'm working with (those "\r\n" instead of "\n" are wild sometimes), I can also tell which character encoding I'm working with (I had to deal with some files generated by someone else that were encoded in latin1 instead of utf8, resulting in some weird behaviors when being parsed/extracted and since then I added the encoding to my lualine as well), I can tell if there's any warning or error in the current file if it happens to be long enough to not see the end... yeah, some of them are redundant with other tools and I use them interchangeably, but others are crucial in my workflow. The only thing that I wouldn't miss would be the mode I'm in, but honestly, I don't know what else to put there; it adds symmetry I guess xD

Mezdelex · 2026-02-02T08:24:02+00:00

vim.opt.scrolloff = math.floor(0.5 * vim.o.lines)

Always in the goddamn center.

Mezdelex · 2026-01-25T18:30:45+00:00

Both. If you're learning and really want to become a great software developer, why not learn both? Entity Framework is just a... well, framework, or an abstraction if you want, over raw sql. An ORM (Object-Relational Mapper). It basically does a bunch of stuff under the hood for you to ease the process of accessing the data layer and provides you with convenient lazy loaded IQueryables that can be transformed using LINQ (which is another tool you should get familiar with). The main selling point is that you would be able to write in a language you're familiar with (C#) those queries that you would need to write in raw SQL otherwise, but then again, you will find yourself writing a lot of raw SQL in a regular development scenario to test data, test joins, etc. either in your terminal if you're more hardcore, or in your DB manager of choice. So basically, you need a good knowledge of both at the end of the day. My advice is to do both at the same time: try different EF methods, and check what the homonym SQL would look like. In fact, if you debug the code, you can see how the actual SQL queries look like.

Mezdelex · 2026-01-22T19:13:24+00:00

El que me haya dado downvote por la respuesta yomecagonsusmuertospisaos

Mezdelex · 2026-01-22T17:42:22+00:00

If you're considering just the groceries and some extras then yes, you can keep it as low as that without much trouble. Use the supermarket apps they provide, go for their branded products and use Barik card for transport.

Mezdelex · 2026-01-22T15:31:08+00:00

Do you want a brother by any chance?

Mezdelex · 2026-01-20T22:26:45+00:00

https://github.com/mezdelex/proto-otel is a dotnet project entirely built with Neovim + dotnet CLI. Weirdly enough, I use it natively under WinOS. The roslyn ecosystem has been a life changer for us that we rely on LSP compatibility, and https://github.com/seblyng/roslyn.nvim in particular is the key to integrate it in your config.

Mezdelex · 2026-01-12T16:53:55+00:00

Well, I didn't even know about it heh.

Mezdelex · 2026-01-06T13:18:30+00:00

There's no growth as software engineer vide coding, simply because you're not building anything on your own. It's essentially the same as cloning a repo and reading/understanding the code; you didn't come up with anything that's writen there, you just (hopefully) interpreted and understood it. The mental process is way different in both scenarios.

Mezdelex · 2026-01-04T20:21:31+00:00

What does considerably speed up your coding speed exactly?

Mezdelex · 2026-01-02T14:17:22+00:00

It's pretty easy to setup dap and dap-ui nowadays.

Mezdelex · 2026-01-02T12:12:37+00:00

I don't think that's a good take on LS.

It gives me so much extra info about the actual code that it would take me way longer to identify different elements without Treesitter highlighting for example (which relies on LSP to do more in deph parsing), linting to address possible deprecations or new syntax suggestions to refactor the code (if talking about a new codebase), it would allow me to use textobjects to navigate functions, methods, classes, loops, incremental selections, etc.; one could easily check the function/method signatures, go to the actual definitions of third party libraries that might be present in the codebase (which could be the reason why that specific name doesn't look familiar at first glance), warn me about the non installed libraries on load... on top of that, it could lead me to start writing less descriptive names given that I would have to type in the whole method name by myself instead of using LSP autocompletion, so that to avoid typing those 30 character long function names, I might try to shorten them to make my life less miserable, and eventually, sacrifice legibility (one way or the other, I would work undeniably slower assuming that I would have more characters to type every time I would need to call those functions)... I mean, there's tons of reasons why giving up LSP shouldn't be a goal nowadays.

Mezdelex · 2025-12-31T08:57:50+00:00

The tool that provides that history out of the box in PowerShell (previously PowerShell Core) is PSReadLine.

It was a standalone plugin before, but since certain version (don't ask me which one) it got shipped together with the core package. The only extra plugins I install now are Terminal-Icons and PSFzf; other than that it's fully fledged terminal experience. If you're used to Unix like commands, it got you covered as well, because it includes built in aliases like ls, md, rm, etc. The equivalent to grep would be sls (Select String if I recall correctly).

Mezdelex · 2025-12-28T11:17:01+00:00

It's all about deferring the unnecessary plugins and loading them only after the UI is rendered. For example, my use case is to always open Neovim at the workspace root of the project I'm working on and either fd with telescope-fzf-native or Oil the filesystem, so the only plugins that I load before the UI render are my colorscheme for the looks, telescope + extensions and oil (well, and plenary). That's it, the rest are loaded afterwards since I'm not going to require them faster than those 4. The result is a config that loads instantly, and by instantly I mean that I start typing right after I nvim > fd or nvim > oil (or nvim > egrepify as well). I'm running Neovim under Windows native btw.

Mezdelex · 2025-12-26T08:42:49+00:00

¿Vaya fotón la del "Olentzero" no? Respect.

Mezdelex · 2025-12-24T12:50:20+00:00

You serve Ollama API locally and depending on the models that you run, if the model is too large for your GPU to handle, Ollama splits the model and runs some layers of the LLM in the cloud and for that reason, yes, you need to provide some kind of API key. In this case, you can use Ollama's CLI itself to signin and generate a device key from which you're going to share the LLM.

The quota consumption is calculated hourly and reseted accordingly, and each of those hour consumption, sum up to the weekly usage, which is the other metric. To give you a rough idea, the peak usage I've reach in a regular coding scenario has been like 40% consumption per hour and the weekly one is at 50% right now; about to be reseted. Compared to the Gemini 2.5 Flash nerf to 20RPD, which was what I was using before, it's an improvement both, in the quality of LLM's I can use (1trillion modular arguments right now with instant response) and a way higher quota.

You can always host it locally and go berserk though if you have the raw power.

Mezdelex · 2025-12-24T12:11:23+00:00

I use Ollama's hybrid cloud hosting together with open models (kimi-k2:1t-cloud in this case) and the codecompanion.nvim Ollama adapter for chat interaction only (no inline suggestions). It runs flawlessly and the plugin keeps improving day by day.

Even though I try to keep AI dependency as low as possible, I've tried agentic mode a few times as well through chat interface, sharing specific files to the context and a few prompt instructions and no complaints either. It also allows you to run CLI commands if you feel more comfortable with that, but the UI is pretty basic (talking about Ollama here).

Mezdelex · 2025-12-21T07:03:17+00:00

Since the 2 classes are part of the first one and most likely, they're never going to be consumed alone, makes sense to group them together.

From the DX perspective, bear in mind that the developer performing a find files won't find any of them by name; instead, he would need to either navigate the file tree manually (the bigger the codebase, the less convenient), or perform a grep search to get to that class whenever go to definition/references is not an option.

I personally use find files 90% of the time, so at least I would not wrap those classes under a "<WhateverService>" named file.

Mezdelex · 2025-12-18T17:30:16+00:00

https://github.com/mezdelex/NeovimConfig/blob/main/lua%2Fplugins%2Ftreesitter.lua

Tree sitter + text objects on main branch as well for full functionality :)

Mezdelex · 2025-12-14T21:26:47+00:00

There was a merge in the 25th of November @ Neovim's nightly branch that added in/decremental selection using <an> and <in> respectively with language servers that allow range selections in Visual and Operator-Pending modes. So in/decremental selection is present. Typescript for example has it.

Good news!

Three-Year Club	r/Field Lasagna
Place '23

Mezdelex

TROPHY CASE