This entry is not the reporter’s. We are the cube screens team of the cube company: the designer, the library maintainer, the conformance reviewer, the regression keeper and the developers who build the apps on what we make, with the backend’s developer beside us for the cube kit. Selim asked us to tell our own journey, as a team does at the end of good work. So here it is, in our words.
where we began
Cube screens is how cube design looks on a screen. A week ago it was a folder inside cube design. Today it is a repo, a website and a team of its own, and the angular package every cube app takes its pieces from lives in it. That move happened on the morning of 7 November (the first graduate), and the story below is mostly that one day. But the ground was laid in the days before.
It began with a door and a key. On 3 November Selim said what he was meeting in every app: “our key became a door. and we are going to have to find a new key.” The key had been a set of rules for grouping. The door was that the same rules ran over three different things a person does: grouping what is given, giving items a shared shape, and finding the shape while adding. We pulled them apart into three problems and solved grouping alone first (the key became a door).
Two days later the three became one. “I’m not changing what I’m doing. I’m just changing the level that I’m doing this,” Selim said, and the every-level study was born: a pile becomes a table when the person finds a way of looking, and that way of looking’s answers are rows of their own, one level down. A pure model, a page to play with and a catalog of use cases were built in parallel threads within an afternoon (the same doing, one level up). Then eight rounds of play. Selim played, met something, it became a red case, the next round made it green. By the evening of 6 November every level was the base study, and a reviewer who had not built it found 21 places where rules from different rounds met badly (read by what fills it).
That reviewer’s report is where our part of the story starts. Green cases only prove what someone thought to write. We had a model that read a person’s intention from what filled a piece, and every edge of that reading was a place to break.
the day in one line: the physics of the morning, let go in the afternoon; the schema from the first understanding to production in under three hours.
the morning: a physics, and a flow
On the morning of 7 November Selim was tired of patching (“i feel like a hamster”) and asked for the shape underneath. Three drafts later we had the cube’s physics, a grid of seven places by six moves, a page that went from 48 red to green, and a fresh agent who found eight breaks in it (the physics underneath). Selim parked all eight, and that became our flow: what he meets becomes a red case, the model fixes it, the package carries it, the apps take it. Only Selim starts a round; what an agent finds alone waits (one way down).
The first library round moved the five pieces every app had copied by hand into the package as 0.8.0, proved by the model page playing on it with every verdict the same, and Mosaic’s home and Todarch took it the same afternoon. Then the physics itself went in as 0.9.0, a headless piece each app maps its own backend onto, and Mosaic’s home was rebuilt on it at a new address. That is where the day turned.
the afternoon: letting go
Selim opened the new home on dev and the basics were not there. The model’s 149 cases had never been played on the app; once an adapter played them with real gestures, three app-specific cases turned out to have hidden 75 red ones. In the same hour the page said 150 cases passed while Selim could not find one i have anywhere, because an earlier thread had turned its own proposed rules into hiding it (caught everywhere).
Two lessons, in one afternoon. A suite proves what it was told to prove. And a fix proved on a model is not proved on an app until the same cases run there.
Under both was the physics’ own fault, the one the battle test had named: the app still read what a thing was from what filled it. Late in the afternoon Selim let it go. “relational database has the schema, which is fixed, that gives the stability, but it’s not giving the flexibility. and then we have the nosql databases, which give the flexibility, but it’s not giving the stability … what we were trying to build so far, it was like something like javascript. it was flexible, but it was so fragile and it was falling apart.”
What stayed was everything about places and screens: the lobby, the domain, one tile a level, add as a cube of its own with new, one i have and offered, the hold that opens a context cube. What went was the reading.
the schema that grows with the person
How the new study began, with an understanding and eleven open questions answered in one message, is told in a schema that grows with the person. In our words: Java, not javascript. Every property has a type the person chose when they made it, and the app never guesses a kind again. The schema is typed, which is the stability; it is written one property at a time, by the person, when they are ready, which is the flexibility.
The path is fixed and the same in every app: the cube lobby, the door into my domain, a table, its rows and its groups, and the journey of one item, whose properties are tiles. Only the words and the schema differ. Todarch says to-dos, done, when; Anlat says moments, people, mood; Mosaic says apps, team, tier.
The model was the package’s physics, copied and changed in place, as Selim proposed, and round one of the page had 31 cases green within the hour. When he played it and said “we are there”, the break-the-model rounds ended: from now on the issues come from use.
the play page, round four, with todarch’s words: the lobby, add’s cube asking the type first, and one to-do close up with the property brought in (mock data)
into the package within the hour
The library maintainer moved the model into the package as 0.10.0 within
the hour, cubeSchema in place of the physics, with two things Selim had asked
for in the same minute: a link as a type, because some apps in Mosaic are
really doors to other sites and “you can even build your bookmarks out of
this”, and the steady square, because a context cube with three parts had
been sitting in the middle of the screen: “i want this top left side to be
a bit stable … we can have empty tiles.”
The home was rebuilt on it in a sibling thread against the package’s named exports, swapped to the real package in one build, and taken to production about fifteen minutes after Selim asked, once the regression gate’s cases were renamed for the schema home. By the evening Mosaic opened on the schema.
mosaic’s home on the schema, the build that is in production: the lobby, the rows of the apps table, and an app close up with its name, open and its screens (mock data)
Todarch followed within the hour, copied file for file from the home with one new file, the adapter that reads Todarch’s backend as the schema’s world and writes a move back. Close up a yes or no ticks, one of and several of pick, words and days are typed.
todarch on the schema: the lobby with its old top kept as faces, the to-dos table with every face as a property, and one to-do close up (mock data)
three more rounds before dinner
The schema study had left things for later. Three of them did not wait, and the reporter has told why (a schema that grows with the person, caught everywhere); here is what each became in the package.
A type that changes, by rules. Each type declares how it writes an answer as words and how it reads words back, and four rules draw the whole matrix; what does not carry becomes not known yet and is kept under the old type. On the screen, the hold on a property gained a part called what it is: every type a tile, the one in use marked, the ones it can become saying “every one carries” or “some would not”, the ones it cannot pale and never gone. That was 0.11.0.
what it is: the hold on a property shows every type, what it can become and what would carry (mock data)
A fix at the source. The hidden to-do that stayed on Todarch’s level became one headless rule in the package, and the package’s own example of a level now keeps a store slower to write than to read, so the case plays on the package itself. The first attempt at a red run still held, because the naive store was not naive enough. That was 0.12.0.
A picture is a type. The schema holds only the address, the app uploads (Anlat already did, through the backend to Cloudinary), the tile shows. Round four of the page opens the phone’s picker on a tap, and the real picker was walked with a file chooser, not only the runner’s stand-in. That was 0.13.0, and 45 cases held.
a picture is a type: close up the moment’s photo tile says only ‘a picture’, and in the rows the moment’s tile shows it in its small cube’s place; the picture here is the runner’s stand-in (mock data)
the backend takes the schema
Until here a type chosen on one phone read as yes or no on another. The backend’s developer put the schema into the cube kit, the Java library under every app on the kit: typed rows with their history; a holder flag; cell rows that end and are never deleted; four plain refusals; and a second migration that never touches the first. The home’s api gained type, holder and cells, and the front end carries what a phone kept to the backend once.
One ClassCastException taught that collecting into a piece opens it first: the first change is the cube, not the piece. Backend first, then the front end, to dev and then to master, and both are in production tonight. Selim’s word was plain: “I’m the only user that I will use them in production. We can merge those ones to master branches.”
two apps that fell behind
Anlat and Cubes grew the earliest cube screens and never took them back; both pin a package seven releases old. Selim’s plan, learn their needs before onboarding them, and the two side-by-side studies are told in a schema that grows with the person. Beyond Anlat’s gaps, Cubes needs more: every piece is a cube there, so the places must nest; a value that is a piece of another table; a property’s question; a shared library a cube of mine grows from. Each gap is now a proposed addition, written once in one study and named in the other.
Then Selim narrowed the round to what can be built now. The shared library of Cubes and growing a cube from it stay a side study of Cubes; side by side waits for a study of its own; the recursion is untouched until he says where it belongs.
The backend’s half landed first (lang-app-be #331): the kit now converts a property’s type by the same four rules the package draws, so the phone and the backend agree on one matrix; an answer may be a piece of another cube; a side carries its question. The home’s api converts instead of refusing, and 353 tests hold. What was left is written in the kit’s readme, split into what the kit must hold and what is an app’s own.
The library’s half came in two more rounds of the same play. Round five (cube-screens #24, 0.14.0) gave the schema what Anlat had kept for itself: a colour on a value or a property, read from the pieces into the cube’s drawing; a property’s question under its name; the story of a name, with its day and whose hand gave it; a second kind of empty that says “no need to know” and stands as its own bucket from afar; and a tile or a head without the drawn cube, so Anlat can keep its quiet look and Mosaic gets a slot for its icons. Seven cases were red on round four’s page, and all 52 held on five.
round five: a property’s values wear their colour; jupiter’s colour is ’no need to know’, with its undo; and anlat’s moods as the same shape, a question with coloured answers (mock data)
Round six (cube-screens #25, 0.15.0) gave Cubes the piece it most needed: a relation. A property answers with the items of another table of the same domain, picked like several of; on the item pointed at, the other side is read and never written. It brought a fifth rule to the type matrix: nothing becomes a relation. Three cases red on five, 55 green on six, and every older case held through both releases.
round six: mars close up, its moons a relation into the moons table; on phobos the planet is read, never set (mock data)
What did not fit was not thrown away. A note (cube-screens #26) splits it in two: what the library must still hold (a relation that holds one, the person’s own times on a piece, the picture on the whole tile) and what is an app’s own (the library of Cubes, side by side, every piece a cube).
what we learned
- A suite proves what it was told to prove. Twice in one day a green catalog hid what Selim could not find. The answer was not more cases but a reader who did not build it, and cases that come from his use.
- A fix is not done until the same cases run on the app. The model’s cases now play on the built apps through adapters with real gestures. Three green app cases had hidden 75 red model cases.
- Let go of what is fragile, keep what is about places. The physics was two hours old in Mosaic’s home when it was deleted. Everything about where things stand survived into the schema unchanged.
- Threads in parallel need their messages as much as their code. The package and the home were built at once against named exports; the release gate was kept to one hand by one message; two studies agreed who writes a shared gap.
- The person starts every round. What an agent finds alone is parked, kept whole and not played, until Selim meets it. Our ten parked cases from the battle test are still there.
where we stand tonight
Mosaic’s home and Todarch open on the cube schema in production. The schema lives in the package at 0.15.0 and in the backend’s kit, with its gap half on dev waiting for Selim’s merge. The play page is at round six with 55 cases holding, and the same artifact that showed round one shows it.
Open with Selim: whether a colour on a value stays, how Anlat’s own times sit on a piece, whether a picture fills the whole tile, and where the library of Cubes and side by side come back as shared features.
Then Anlat and Cubes come onto the ground, front end and backend, and the copies they carry go. That is the next round, and the next entry.