HNHacker News
TopNewBestAskShowJobs

robertsdionne

67 karma · joined April 28, 2016

submissionscomments
robertsdionne··on Google is shutting down Stadia
St(r)eam.
robertsdionne··on Why modern software is slow
notepad dot electron
robertsdionne··on Learn TLA+
Does TLA+ support double-primed variables? Like second-derivative sort of thing.
robertsdionne··on Why adults still dream about school
I have a recurring dream where the university revokes my diploma years after graduating because I actually somehow dropped out of all my classes and forgot to finish the final projects/exams.

That never happened, but I did drop a couple classes before the withdrawal deadline to fix the workload. It feels so real though.

robertsdionne··on Show HN: Distributed SQLite on FoundationDB
"The SSD storage engine stores the data in a B-tree based on SQLite." XD https://apple.github.io/foundationdb/architecture.html#stora...
robertsdionne··on Ask HN: What are some cool but obscure data structures you know about?
Also, Learned Indexes Structures:

The Case for Learned Index Structures: https://arxiv.org/abs/1712.01208

Learned Indexes for a Google-scale Disk-based Database: https://arxiv.org/abs/2012.12501

And Noms/Dolt Prolly Trees:

How to Chunk Your Database into a Merkle Tree: https://dolthub.com/blog/2022-06-27-prolly-chunker/

robertsdionne··on Ask HN: What are some cool but obscure data structures you know about?
Seems to me to be quite similar to the virtual pages in Bw-Trees: https://www.microsoft.com/en-us/research/publication/the-bw-...
robertsdionne··on Ask HN: What are some cool but obscure data structures you know about?
Posit numbers (a better floating point representation): https://www.johndcook.com/blog/2018/04/11/anatomy-of-a-posit...

https://www.johngustafson.net/pdfs/BeatingFloatingPoint.pdf

robertsdionne··on Postgres full-text search: A search engine in a database (2021)
You can use the pg_trgm extension.
robertsdionne··on Go Developer Survey 2021 Results
via https://rakyll.org/generics-facilititators/

Example: https://go.dev/play/p/as3rT4fB3cn

  // Invocation:
  strings := []string{"1", "2", "3"}
  
  ints, err := Mapper[string, int](strings).MapErr(strconv.Atoi)

  strings = Mapper[string, string](strings).Map(func(s string) string {
    return s + "_suffix"
  })

  // Definition:
  type Mapper[T, U any] []T
  
  func (ts Mapper[T, U]) Map(f func(T) U) (us []U) {
    us, _ = ts.MapErr(func(t T) (u U, err error) {
      u = f(t)
      return
    })
    return
  }
  
  func (ts Mapper[T, U]) MapErr(f func(T) (U, error)) (us []U, err error) {
    us = make([]U, 0, len(ts))
    for _, t := range ts {
      var u U
      u, err = f(t)
      if err != nil {
        return
      }
  
      us = append(us, u)
    }
    return
  }
robertsdionne··on Dall-E 2
https://en.wikipedia.org/wiki/Universal_approximation_theore...
robertsdionne··on Windy.com
https://earth.nullschool.net/
robertsdionne··on Distributed search engines using BitTorrent and SQLite
Merkel Search Trees are like B-Trees, as described in https://hal.inria.fr/hal-02303490/document, since internal nodes can store values.

Whereas Noms Prolly-Trees are like B+Trees, since all values are stored in the leaves.

Merkel Search Trees use the prefix of the hash of inserted keyvalues (number of leading zeros) to determine which layer will contain that keyvalue. This provides a deterministic tree structure for any given set of keyvalues, when you arrange them by key order.

Noms Prolly-Trees use a rolling hash across the sequence of keyvalues to determine split points, similarly when the number of leading zeros exceeds a threshold. Then those leaves are assigned as children to keyvalues on the next highest layer, which is again split in the same way, until a single root node is left.

robertsdionne··on Ask HN: Best Talks of 2020?
https://db.cs.cmu.edu/seminar2020/
robertsdionne··on Waymo pulls back the curtain on 6.1M miles of self-driving car data in Phoenix
You can have tiny roundabouts: https://www.google.com/maps/@32.2437203,-110.9539392,84m/dat...

This one is also a 4-way, haha.

robertsdionne··on Entropy Maximization and intelligent behaviour
Maybe like https://pathak22.github.io/noreward-rl/
← PreviousPage 2 of 2