So I have been working for a year or so for Knowledge Futures Group. Over the year or so, I have learned. Grew even. Here are some of my takeaways:
Everyone should go camping. I mean hike a few miles up a hill. Set up a tent. Bring shrooms and weed. Food. Start a fire. Sit there. You will get bored quickly. We are the smartest things we know on earth. Maybe not as impressive as dicty but humans are impressive objectively. That means working is more of a pastime as we build shelter, negotiate society, party, and get about. It’s probably the case this arrangement can be rewarding, at least personally. I don’t mean through work, however. I mean through creating a life that’s reasonable and desired. Whether or not work is enjoyable is really a luck of the draw. But creating a life of your choosing is the primary value proposition of democratic societies. That means work-life needs balance with the superset of all life. But type theory is later.
Aside from being remote, and offering a competitive wage, and benefits1, KFG did two things to make this a feasible task. First, we have a four-day workweek. I have so much time to organize my life and thoughts. The second is KFG adopted some pretty novel stances toward compensation policy.
“Whenever someone is given a salary adjustment, including when a new hire is made, everyone else in their role and level who received a satisfactory performance review in the last cycle must be brought up to the highest salary level in the company at that role and level. In this way, we help bargain for employees automatically, reduce bias, reduce the cost of staying at the company vs. seeking a new job, and allow employees who receive less than satisfactory evaluations but later improve to catch up quickly.” - from a soon to be released draft of our open compensation policy
For years I have had an issue with implementing a system that can facilitate reading, note-taking, and writing. College is horrible when you stay in the library but can’t get the results you want. Honestly, I’m offended physical flashcards exist. I won’t go into “productivity hacks“ here, but recently I was accepted into the alpha testing of reader. My entire thought capture flow changed after committing to using reader, to, well read. Now I can read and sync annotations to note-taking apps, make connections about things I’m reading, and write about the things I’m thinking about in one web of interconnected applications. The problem is I do this all outside of PubPub.
That’s why I think any open-source product should probably ship with a handful of useful integrations into other services. Granted, I think PubPub has a different value prop than say obsidian, but not being able to port my connected thinking and long-form writing makes PubPub a serious chokepoint for putting out thoughts. Like I should be writing this in obsidian and using some publish to PubPub library to import the markdown as well as any linked docs as citations. Not being able to do this makes writing about things in an open space a chore.
I mean I wont beat a dead horse. Our head of operations has already written about this.
Also, read this.
I'm not really sure how Bezos came to this realization -- the insight that he can't build one product and have it be right for everyone. But it doesn't matter, because he gets it. There's actually a formal name for this phenomenon. It's called Accessibility, and it's the most important thing in the computing world.
For quite some time I have wanted to know what a type is. Currently, I’m going through a collection of articles, including the TS handbook, research on dependent types, and metaprogramming. So far what I’m getting is that self-compilation is not mutually exclusive from type theory. That’s about it. JavaScript is one of the world’s foremost languages. When Microsoft engineers wanted to do more web stuff they began to port C++/C#:
Various early solutions worked on by Microsoft and other web-scale companies were mostly efforts to compile traditional languages such as C++ into JavaScript, though this left developers at “an arm’s length from the platform,” - The New Stack
But that’s a bad solution so they made typescript.
If there is a secret to the success of TypeScript, it is in the type checking, ensuring that the data flowing through the program is of the correct kind of data. Type checking cuts down on errors, sets the stage for better tooling, and allows developers to map their programs at a higher level. And TypeScript itself, a statically-typed superset of JavaScript, ensures that an army of JavaScript programmers can easily enjoy these advanced programming benefits with a minimal learning curve.
What this means for the future is a highly flexible expression of declarative routines. These routines can be typed in such a way that they generate code. This is bleeding-edge stuff according to Wikipedia.
Usage of dependent types allows proving that generated code is never invalid. However, this approach is bleeding-edge and is rarely found outside of research programming languages.
But very reminiscent of something I was introduced to at PubPub.
Ian introduced a new way to consider modeling something I best conceive of as state. State is transient. It can change. But the data structures that compose them should not. At the end of the day, an application is a data structure for memory i/o.
Thinking this way has some important consequences I am not yet fully able to contend with. Is there a universal data structure? What is a type? A statically typed application is not a supertype, is it? I think it dates back to compilers, see self-composition. I do not know.
I do know an application written in JavaScript uses objects to define objects. We can add steps to get these objects called functions. We make a function and get an object, but really we are mutating a global object. With what Ian calls Facets we can mutate and generate state for our parts of the global object. We would be doing some pretty bleeding-edge stuff2.
All this has made my brain hurt3.
In the context of PubPub this could give us something like a DSL language dynamic type system thing. I can no longer think of modeling objects and deriving their properties in TS without this now4. Consider an object we want to load differently when a different set of properties exist for different instances of the object
scopeA->propertyBinding->{propertyA, propertyB}
scopeA1->propertyBinding->{propertyA, propertyC}
It should follow that we can create a complete object for each scope, and mutate its values based on the presence of a different set of properties.
We can generate strongly typed functional objects from schemas. And model them as separate mutating graphs of cascading scope properties.
Ian helped me think through this and it turns out Eric was working on a entity component system5
so imagine there’s components:
type Position = { x: number; y: number };
type Health = { health: number; };
type Damage = { radius: number; deltaHealth; };
then you have archetypes:
type Player = Position & Health;
type Enemy = Position & Health;
type Bullet = Position & Damage;
type Grenade = Position & Damage;
which is a kind of contrived example
[11:18 AM]
but the point is that because `{Player, Enemy}` and `{Bullet, Grenade}` have the same total set of properties (derived from the union of all their components)
and even though they may have very different behavior implementations
you can _store them together_ in an array of homogenous data structure that holds all of their properties (edited)
and the shape of which is pre-computed at compile time
and in gamedev there are CPU and memory-related incentives to do this
[11:19 PM]
I’m probably getting this wrong and Eric will yell at me
Coding is a lot. Recently I described it to a colleague as if you had to find a new way to express yourself through a culture every 6 months. If you do not you will stagnate. Or I mean, go work for the government. Entire languages are adopted or created based on language tooling6. As an application begins to resemble a system, you now need rules and procedures to interface with the human part of that.
Adding a field to a database for example is a trivial task when it’s like four or five people making additions. I will manually add a table to a DB every day bc it’s more convenient. I would prefer DB migrations to run as a result of a model updated in code. Without me thinking about it. But a simple DB CLI is a basic must.
We are in the middle of a golden age of server orchestration. Putting files on servers and accessing them is a hard thing. But I don’t think making a web app and exposing them will be an issue in the future. Providing a consistent development environment, continuous integration to the cloud, continuous deployment strategy, and maybe some testing is. All are necessary to make setting up an open-source project a reproducible-enough event.
We do collaborative work. Everyday. Someone is working on something that someone else will look at. We have a host of methods to do this. OpenAPI, PubPub, Github, Heroku, Slack, Code, etc. I have found that a strategy for making a knowledge base around development may be better. I think that requires note-taking during development. We create specs for our projects sometimes. Tools like Notion get this by offering configurable collaboration tools. Allowing entire dev flows to be maintained there. A collection of any serious thoughts on development through time could be very useful.
Creative Commons Attribution 4.0 International License (CC-BY 4.0)