HN

Comments (101)

• Menu

  jvolkman
  > Protobuf now has modern IDE support for the first timeWeird 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
• Menu

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

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

  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!
• Menu

  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.
• gjvc
  "You're welcome." is such a smug verbal tic.
• Menu

  nullbio
  Protobuf getting LSP support before Codex implements LSPs is wild.
• Menu

  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.
• Menu

  deepsun
  Unpopular opinion -- LSPs are bad because they introduce latency into coding. For every keystroke, my IDE needs to make request/response with LSP, instead of using its own internal parser/colorer/autocomplete.
• Menu

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

  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
• anon
  undefined
• Menu

  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.
• blackbriar75
  [dead]
• Menu

  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.
• Menu

  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.