1. 37
  1.  

  2. 8

    The output is distinctly like that of https://github.com/lambdaisland/deep-diff2 which uses An O(NP) Sequence Comparison Algorithm via clj-diff.

    The algorithms in Clojure libraries got a serious comparison & benchmark in https://juji.io/blog/comparing-clojure-diff-libraries/ which was thorough. It seems that O(NP) Wu et al. 1990 is a winner for speed.

    I’d love to know how Graphtage’s algorithm compares with the existing literature, the description sounds novel.

    1. 3

      Almost ignored this assuming it’s nodejs portfolio puffware. But it looks like real work, from the “trailofbits” umbrella (source of algo vpn, by far the best VPN experience I’ve ever had).

      The blog mentions a related tool polyfile which looks seriously cool. And something unrelated called Sinter.

      1. 2

        What is a “nodejs portfolio puffware”? I find this espression amusing

        1. 8

          puffware = software that looks cool (bootstrap, hero image) but scratching the surface reveals shallow, half-baked demoware or a broken wrapper around actual software. Adds twitter followers.

      2. 2

        Not exactly the same thing, but does anyone have any experience with Semantic Merge? It seems interesting, but I haven’t known anyone that’s used it or spent enough time playing with it.

        Huh, further investigation shows that the company behind SemanticMerge just got bought by Unity. Well, that probably means it will either die a quiet death or become part of Unity tooling (which I don’t have any experience with).

        1. 2

          I was a curious whether this recognized common sub-expressions through structural changes (e.g., a complex object moving from .a.b to .c). It doesn’t (unsurprisingly, and I’m not saying it should); I wonder whether that could be added as a new kind of “edit”?

          {                          
              "̶a̶"̶ -> "̟c̟"̟: {
                  "b": 12345
              } -> 12345
          }
          
          [                          
              [
                  "hello world"
              ] -> "hello world"
          ]
          
          [                          
              [
                  "key",
                  "value"
              ],
              [
                  "key2",
                  "value2"
              ]
          ] -> {
              "key": "value",
              "key2": "value2"
          }
          
          {                          
              "result": [
                  1,
                  2,
                  3
              ]
          } -> [
              1,
              2,
              3
          ]
          

          (The output is pretty hard to parse without color.)