Arguing against using protobuffers

it doesn't mean that there is a single solution that will satisfy everyone

The argument presented is that protobuf does not attempt to even replicate the best practices we already have in terms of data representation. It makes sense why languages like C are constrained in their data representations -- they want to be close to the machine. However, a language meant literally to specify data really ought to be able to handle the basic competencies of its field (like sum and product types and polymorphism) with ease.

There is no excuse in 2018 for a data language without polymorphism and without product and co-product types. Compatibility with legacy or substandard languages is not an excuse for poor design. Compatibility with needed legacy languages should be the thing that's tacked on, not basic functionality.

   struct mytype s;
   s.field1 = something;
   s.field2 = something else;
   send(socket, &s, sizeof(s), 0)

   data MyData = MyData Int Int deriving Generic
   instance Storable MyData

   alloca $ \buf -> do
     let d = MyData field1 field2
     poke buf d
     send socket buf (sizeof d)

Go has its own philosophy about zero values which is controversial, but at least with pointers you do get to express optional values. And it's not like you can't work around the ergonomic awkwardness that arises:

  type Post struct {
    Title *string
  }

  func (p *Post) GetTitle() (string, bool) {
    if p.Title == nil {
      return "", false
    }
    return *p.Title, true
  }

  func (p *Post) SetTitle(s string) {
    p.Title = &s
  }

Go also run into the same issue when encoding and decoding JSON. Most languages do distinguish between empty string and a missing string, but not Go, which makes it hard to validate anything. I wrote a code generator for JSON Schema [1] recently, which applies validations while deserializing, and has to resort to a rather low-tech trick to do so:

  type Post struct {
    Title string `json:"title"`
  }

  func (v *Post) UnmarshalJSON(b []byte) error {
    var raw map[string]interface{}{
    if err := json.Unmarshal(b, &raw); err != nil {
      return err
    }
    if _, ok := raw["title"]; !ok {
      return errors.New("field title: must be set")
    }
    type plain Post
    var p plain
    if err := json.Unmarshal(b, &p); err != nil {
      return err
    }
    *v = Post(p)
    return nil
  }

C and Go are in the minority here. This doesn't come up in languages like Rust, Swift, TypeScript, Nim, Haskell, OCaml, C#, F#, or Java >= 8, all of which have some sort of optional support (algebraic data types or built-in). For example, TypeScript:

  interface Post {
    title?: string
  }

  struct Post {
    title: Option
  }