14 Matching Annotations
  1. Jul 2021
    1. I conclude that there are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies.

      two ways to construct software

    1. Lazy thinking is making decisions through broad, imprecise beliefs which are either impossible to test, or one is too lazy to adjudicate. Lazy thinking is assuming statements that are intuitive are true without properly assessing if data backs up the claim. Lazy thinking is believing the convenient “truth” because it conforms to the path you are already marching along.

      Good definitions of lazy thinking

    1. PathQuery does not have a way to perform aggrega-tions based on groupings of arbitrary variable values.Put more simply, there is no genericGROUP BYfeature.

      lack of group by

    2. A drawback of PathQuery’s approach is that it does notsupport unbounded variable-length edge traversals. A maxi-mum bound must always be specified. However, because thisfeature builds on a general concept of recursive functions, thenature of these “traversals” is much more powerful, since afunction definition can be any conceivable PathQuery. In thisregard, PathQuery is more similar in power to Gremlin inthat the “traversals” are not limited toregular path queries

      This and lack of arbitrary group bys seems limiting.

    3. A predicate used in this fashion eectivelytraverses the outgoing/nameedges from the nodes identifiedby the inputs, and outputs values identifying any nodes thatare reached from the traverals. In short, predicates are thesyntactic structure for edge traversal.

      I like the idea of defining edge traversals as predicates. It's obvious once stated.

    4. Semantically, a path is a function from collections tocollections.

      key idea behind pathquery

    5. PathQuery was originally designed withonly Google’s KG in mind. The KG is eectively a set oftriples, each of which consists of three parts: asubject,apredicate, and anobject. From PathQuery’s perspective, KGsubjects are alwaysIds, whereas objects are any non-Recordvalue. The predicate is basically a string, although PathQuerydoes not view predicates as values.

      triples: subject, predicate, object subject is always an Id object is always a non-record value

    6. there appeared to be roughly two categories of graph querylanguages: (1) those similar to SQL, and (2) proprietary lan-guages. Google needed a graph query language that couldscale to its large number of developers without requiring deepexpertise. Thus, to be intuitive, the graph query languageneeded to be naturally “graphy”, which in our opinion ruledout the languages that were similar to SQL. Such languages– while having basic graph pattern matching mechanisms –ultimately require pivoting a developer’s mindset into a rela-tional space, instead of a “graphy” space, when attemptingany non-trivial query. Additionally, proprietary languageswereproprietary, oering little or no formal foundation forsemantics, much less any well-defined opportunities for queryoptimization.

      good overview of why a graphy language might be desirable vs sql

    7. This form of querying feels much more “graphy” to us.However, when considering how to implement a system forthis language, it is unclear how we could implement flex-ible and automatically-optimizing query planning for thislanguage

      It's unclear to me what the equivalent pathquery query provides in it's syntax that isn't provided in gremlin. perhaps this statement is only true for more complex query shapes?

  2. Apr 2021
    1. The dramatic question tells us (the audience) what is at stake in the scene. Why is the scene important? Why is it worth playing? What is it we need to find out in this scene? And when we have the answer to that question, the scene is over.

      each encounter should answer a dramatic question

    1. One of the main characters in DS9 was a member of an alien species called the trill. And the trill are two-part life forms. They’re two separate organisms. A humanoid host and a slug-like organism called a symbiont that’s surgically shoved into the host’s abdomen and grows into its central nervous system. Each is its own thing. The host and the symbiont have different personalities, minds, memories, the whole thing. And the trill’s personality and mannerisms become a unique blend of the two different entities. Eventually, the host dies. It’s got a normal humanoid lifespan. But the symbiont can survive and get implanted in some other host with all its previous memories intact. And the new trill’s personality and mannerisms become a synthesis of the new host’s personality and the symbiont’s personality based on all its lifetimes of experiences and memories. And that’s how role-playing works. Role-playing isn’t pretending to be someone else because you just can’t ever do that. Like it or not — and lots of people resist this basic truth — you can’t take the you out of role-playing. Whatever character you play, you’re still the slug in the character’s stomach. All of your own personal experiences, beliefs, perceptions, attitudes, ideas, and priorities come along for the ride. In the end, it is still your brain making whatever decision the character makes. And your brain’s decisions are the result of its wiring. And your brain’s wiring is a result of your genetics and biology and how your brain’s wiring has developed in response to your experiences. Nature and nurture. That old yarn. You literally cannot think like anyone other than you for the same reason you can’t bend your knees backward. It’s a hardware problem. Besides, to think like another person would require you to hold an infinite set of memories, experiences, beliefs, priorities, natures, and so on in your head. Perfectly. Because all of that s$&% figures into every decision you make, no matter how simple. And, guess what? You can’t do that. Role-playing’s thus not really about pretending to be someone else. It’s about making the choices you would make in a given situation if you were a certain character. Role-playing is saying, “okay, so, this dragon is descending on the town. What would I do in this situation if I was a bada$& barbarian dude from the hill tribes in some fantasy world?” The question’s not “what would Angrar do?” It’s “what would I do if I were Angrar?” It’s a subtle distinction, but super important. The character you play is always “you, but…”

      a great explanation of how to role play a character

  3. Feb 2021
    1. w-level assembly language for the cloud, a simple in-frastructure for launching sequential code, a UDF frameworkwithout a programming model to host it.

      functions as a service is a low-level assembly language for the cloud

  4. Jan 2021
    1. Apple had a very clever idea in defining Directly Responsible Individuals (DRIs) for everything. Having a name accountable instead of a vague "the team" or "the process" makes it easy to make changes

      this is similar to my primary/secondary system at SingleStore

    2. every document could disappear 6 months after it's published unless whoever uploaded or created it says otherwise in an email the system sends them after six months, documents shouldn't live rent free

      this is a great idea to ensure that documentation doesn't become stale.