simonz05

This type of runtime type checking is quite common in Go. An example from bufio.Reader's WriteTo method:

  // WriteTo implements io.WriterTo.
  // This may make multiple calls to the [Reader.Read] method of the underlying [Reader].
  // If the underlying reader supports the [Reader.WriteTo] method,
  // this calls the underlying [Reader.WriteTo] without buffering.
  func (b *Reader) WriteTo(w io.Writer) (n int64, err error) {
   b.lastByte = -1
   b.lastRuneSize = -1
  
   n, err = b.writeBuf(w)
   if err != nil {
    return
   }
  
   if r, ok := b.rd.(io.WriterTo); ok {
    m, err := r.WriteTo(w)
    n += m
    return n, err
   }
  
   if w, ok := w.(io.ReaderFrom); ok {
    m, err := w.ReadFrom(b.rd)
    n += m
    return n, err
   }
  
   if b.w-b.r < len(b.buf) {
    b.fill() // buffer not full
   }
  
   for b.r < b.w {
    // b.r < b.w => buffer is not empty
    m, err := b.writeBuf(w)
    n += m
    if err != nil {
     return n, err
    }
    b.fill() // buffer is empty
   }
  
   if b.err == io.EOF {
    b.err = nil
   }
  
   return n, b.readErr()
  }

We recently went through a similar situation at a logistics company in Europe. We decided to bring software development in-house after facing similar frustrations with a third-party provider. It was a challenging process, especially in attracting talent, but ultimately, it allowed us to build a solution tailored to our needs.

I’ve been with the company for the past 4 years, working as a lead software engineer. If you’re interested, my contact details are in my profile, and I’m happy to setup a call

I understand and respect your perspective on Austin and Cherry’s involvement in the Go community. Their contributions may indeed be less visible but still impactful. However, the community’s perception of leadership is crucial, and visibility plays a big part in that. For instance your long form blog adds context to decisions you’ve taken in the past. I hope their active roles will become more apparent, fostering a stronger connection with the broader Go community.

> I'd also like to see less google control of the project.

That doesn't look like is going to happen — the leadership change announced here seems to me to continue on the Google path. Both Austin and Cherry are relatively unknown outside Google and are to my knowledge not active in the community outside Google.

I cannot remember (or find) where I signed up for updates, but I get an email every 6 months (or so) from Lorenzo Stoakes personal email. Probably just send him an e-mail and he'll add you to his list.

Lsm trees also need a log, right?

In-process database like SQLite is the holy grail for low-latency database access on the edge. However, the synchronous I/O is holding it back, but how does in-process database look like with asynchronous I/O?