NoProto
gogen-avro
NoProto | gogen-avro | |
---|---|---|
8 | 2 | |
364 | 359 | |
- | - | |
0.0 | 4.2 | |
11 months ago | 3 months ago | |
Rust | Go | |
MIT License | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
NoProto
- Flexible, Fast & Compact Serialization with RPC
- NoProto: Flexible, Fast and Compact Serialization with RPC
-
Writing no_std-friendly libraries?
You can easily use allocation and allocation dependent data types with the ‘alloc’ crate. Everything in the alloc crate will honor a global allocator set by the host application. I built a no_std crate with allocation, if you’d like to check it out for examples: https://github.com/only-cliches/NoProto
-
Introducing nachricht: a self-describing binary data-interchange format that uses backreferences to save bytes on wire
Looks awesome! Do you mind if I add this library to my benchmarks? https://github.com/only-cliches/NoProto#benchmarks
-
Looking for simple avro like serialization format
There is now: https://github.com/only-cliches/NoProto/issues/10
-
rkyv 0.3: Unarchiving and perfect hashing
I'm trying to add your library to my benchmarks and it's seg faulting. It's possible I'm doing things wrong, but once I reach this method the benchmark fails and segfaults.
-
rawbson: A new non-allocating BSON handling crate
Benchmark Source
gogen-avro
-
NoProto: Flexible, Fast and Compact Serialization with RPC
This seems pretty confused. The "compiled vs dynamic" distinction is a property of the implementation, not of the protocol.
For example, you can certainly compile Avro into Go source files [0]. You can even compile Avro loaded schemas _during runtime_ into Python bytecode, since Python is interpreted [1]. This even works if you have the _wrong schema document_ for the message (you'll just get the subset of fields which are accurately described), because of Avro's schema compatibility rules.
Likewise, you can deserialize arbitrary protobuf messages during runtime without a compilation step, if you have a description for the message schema. The Python protobuf library has had a "ParseMessage" API forever, and protoreflect [2] exists for Go. (In case it's not obvious, I mostly work in Python and Go but I am completely certain analogues exist in other major languages).
There is a very big and important difference between a protocol and the implementation of a protocol. I think this README's author is not clear on that difference, which shows up in other claims ("Deserialization is incrimental", for example) too.
---
[0] https://github.com/actgardner/gogen-avro
[1] https://github.com/spenczar/avroc
[2] https://pkg.go.dev/google.golang.org/protobuf/reflect/protor...
-
Feature complete Kafka client written in Go
at my company, we ended up writing a client on top of the Confluent client (which hooks into the librdkafka C library) and uses the gogen-avro library to provide type safe codegen for Avro schemas and is used for the serde process within the client. the API ended up looking basically like the standard Java API. as for feature parity, librdkafka seems to provide most of what we've needed from a Kafka producer/consumer config side of things while the SR implementation is limited in scope anyways and can easily be included in a basic library.
What are some alternatives?
rkyv - Zero-copy deserialization framework for Rust
kowl - Redpanda Console is a developer-friendly UI for managing your Kafka/Redpanda workloads. Console gives you a simple, interactive approach for gaining visibility into your topics, masking data, managing consumer groups, and exploring real-time data with time-travel debugging. [Moved to: https://github.com/redpanda-data/console]
bebop - 🎷No ceremony, just code. Blazing fast, typesafe binary serialization.
avroc - Python library for compiling Avro schemas into executable encoders/decoders
xous-core - The Xous microkernel
sarama - Sarama is a Go library for Apache Kafka. [Moved to: https://github.com/IBM/sarama]
Apache Avro - Apache Avro is a data serialization system.
postgresbson - BSON support for PostgreSQL
muon - MuON data interchange specification
serde-gura - Strongly typed Gura library for Rust
nachricht - A self-describing data interchange format
rawbson - Blazing fast zero-copy BSON handling in Rust.