Protobuf has LSP support. You're welcome

echelon

Buf's offering of protobuf registries and codegen SDKs for microservices seems less necessary in the LLM era. I'm starting to question many of protobuf's advantages (perhaps not the wire format). Add to that monorepos and other fads of the 2010s given the rise of LLMs. I used to be a big believer in this stuff, but I'm quickly having my core assumptions change out from under me.

ltbarcly3

Watch as I don't use protobuf because it is horrible. .... Tada! If you patch clients to google services in Python to use json instead of grpc they get faster and more reliable . A lot faster. Benchmark it! def get_json_client() -> CloudLoggingQueryClient: """Client for log queries (JSON transport, avoids gRPC overhead).""" client = google.cloud.logging.Client.from_service_account_info(...) client._use_grpc = False return client For me that is how I know something like protobuf is good. It is a nuisance to manage and distribute the definitions, adds a build step even to languages with no build step normally, is slower than almost every alternative, and artificially restricts you from doing lots of common things. It's so good! And look at the code quality of the implementation! It's like a team of interns wrote it while drunk. It is a complete spaghetti mess, but has tons of super convoluted micro optimizations that are slower than just doing the most obvious thing, but make the implementation confusing and indirect. It's trash code.

gafferongames

While not a direct competitor to protobufs, if you are working in the video game space where struct versioning is not needed, there is an alternative language called "schema" that supports C, C++, C#, Golang, Rust and JavaScript. https://github.com/mas-bandwidth/schema

eterm

Lots of naysayers here, but an advantage of protobuf is that proto files are hand-writeable, and therefore having an LSP for that could be useful. That said, proto itself dissuades or forbids the kind of common things you might do with a LSP, such as renaming. Renaming fields is a big no-no [edit: this isn't true, see corrections below], as is doing things like re-ordering fields. A core idea of proto is that versions are strictly compatible with with previous versions. This itself has limitations and challenges for migrations, but encourages good practice about compatibility that usually gets ignored or hand-waved away in most ecosystems. I accept however that it's often easy to offload both the re-structuring and the checking of version compatibility to an LLM and let them go at it.

williamcotton

I looked at the dependencies and noticed that it wasn’t using an existing Protobuf parser which means they reimplemented the parser from scratch. Perhaps due to a lack of error recovery in the existing implementations? I don’t have the energy right now for further inspection. It is definitely best to reuse the parser for the runtime when implementing an LSP but to do so properly means implementing the parser itself as a standalone library. Even better is shipping the semantic analysis as well! Implementation drift is definitely an issue. But great project anyways, just wanted to put my thoughts on the matter into the conversation!

PufPufPuf

Buf does great work at fixing Protobuf to the point of being just barely usable. A godsend if you're stuck with Protobuf/gRPC on a legacy project.

lacoolj

"You're welcome" is absolutely hilarious to read from a company post.

unprovable

From protobuf to quantum computing, Google just keeps solving problems nobody has...

alecthomas

What an oddly arrogant post, there's been a Protobuf LSP available for years: https://github.com/lasorda/protobuf-language-server

aussieguy1234

I've always thought of protobuf as a Java thing. It worked great in Java, but not so well in JS, especially with Kafka.

gjvc

"You're welcome." is such a smug verbal tic.

jvolkman

> Protobuf now has modern IDE support for the first time Weird post. I built IntelliJ protobuf support [1] while at Google like 10 years ago, and it started shipping by default with IntelliJ in ~2021. Maybe that's not considered "modern". [1] https://github.com/jvolkman/intellij-protobuf-editor

nullbio

Protobuf getting LSP support before Codex implements LSPs is wild.