COSMOGENESIS

What it does

Reading the logic is how you come to see the system.

Ask what a figure is made of, what a change would reach, and what the evidence was. Each answer is read out of the code your systems run on.

Cosmogenesis reads the source code your organisation runs.

Many into one

Every system you run, whatever it is written in, read as one.

A database, a program, an integration package, a scheduler, a screen and a model are written in different languages and kept apart.

The reading compiles each into the same representation of typed operators and graded field edges, so thirty-two dialects become one graph. Each dialect is read by an adapter written for it. The lineage then rolls up at four levels. Physical is column and table, and it is where the in-depth analysis is done. The logical, conceptual and business levels condense it, and they are what carry the meaning.

At the left, Eight lanes of unlike things an organisation runs, drifting toward one intake, with five of them named: last night's position load, the month-end figure, the schedule that runs it, normalising the raw value, the external rate lookup. In the middle, one turning aperture every lane passes into, with a chute under it and a tray holding the one statement the reading refused, named under the tray: The procedure assembles one statement at runtime before it runs it. At the right, four shelves of one ordered account, each finding marked filled where the reading read it straight out of the code and open where it inferred it: business, 21 items, 14 links, every link graded; conceptual, 136 pairs considered, none corroborated; logical, 6 entities; physical, the reading's own graded chain.The systems you runOne readingOne ordered accountLast night's position loadThe month-end figureThe schedule that runs itNormalising the raw valueThe external rate lookupSet asideThe procedure assembles one statementat runtime before it runs it.Business21 items, 14 links, every link gradedConceptual136 pairs considered, none corroboratedLogical6 entitiesPhysicalDirectly ObservedStrongly Inferred
Stacked for a phone: Eight lanes of unlike things an organisation runs, drifting, among them last night's position load, the month-end figure, the schedule that runs it, normalising the raw value, the external rate lookup; under them one turning aperture every lane falls into, with a tray at its shoulder holding the one statement the reading refused, which is this: The procedure assembles one statement at runtime before it runs it. And under that four shelves of one ordered account, each finding marked filled where the reading read it straight out of the code and open where it inferred it.The systems you runOne readingSet asideOne ordered accountBusiness21 items, 14 links, every link gradedConceptual136 pairs considered, none corroboratedLogical6 entitiesPhysicalDirectly ObservedStrongly Inferred

Eight real programs from two specimen systems, in five languages, five of them named on the drawing. One pass reads them.

The same account at four levels, every finding marked for how well it is evidenced.

The conceptual level came back empty on this specimen, so it is drawn empty.

The physical shelf carries no figure because it is drawn at a different grain. It shows the reading's own graded chain; the engine's physical level counts declared tables, and this specimen declares none.

The one statement it would not read is set aside under the reading, and named there.

Adapters for thirty-two dialects. Which your systems use is settled against your inventory when the assessment starts.

What enters

What you hand over, and on what terms.

Your catalogue keeps the inventory and your monitoring keeps the runs, and we read the code between them.

The catalogue cannot see inside a statement, so the statement is where we start.

How it works across your systems. Four things hold, whatever your systems are built from.

  • What a reading takes today.Code in thirty-two dialects, whether it sits in stored procedures, ETL packages, scheduler and job definitions, views, mainframe programs and their batch definitions, or application code. Twelve of the thirty-two are named here, SQL, T-SQL, DAX, SSAS, Python, C#, COBOL, SAS, VBA, SSIS, Control-M and JCL, and the other twenty are not named on this page. A dialect no adapter reaches is recorded as NOT YET ANALYSED with its reason, never guessed.
  • From statements to one graph.Each statement is compiled to the operations it performs and the fields those operations read and write. From there the systems join into one graph, whatever each was written in, and that is what makes the reading cross-technology. That step is written down in the reading record's own vocabulary, and this is the line it holds. The checked source compiles to typed operators and graded field edges joined by the engine's operator resolver.
  • Every relationship carries a grade.The four grades set out below say what the source could evidence for a relationship. Where the evidence runs out the reading records a refusal and keeps the reason with it.
  • The access is read-only, granted and revoked by you.What it takes for your reading is agreed at the start of the assessment, against your own inventory.

A second synthetic reading, shaped like a bank's month end, is on the Evidence page. See the second reading.

What one statement becomes

How one statement becomes three graded relationships.

The statement is the specimen's normalising step. What came out of it follows, field by field.

A reading is compiled from the source you supply, and the same source gives the same record, byte for byte. No model is involved.

One normalising statement in its own six lines, and beside it what the reading takes from it: the fields it reads, the fields that come out of it, the typed operator the record names, each relationship with the grade the record gives it, and a strip marking where in the route this one statement sitsONE STATEMENT AND EVERY RELATIONSHIP IN ITTHE CODE AS WRITTEN02_normalise.sql-- Synthetic Theory fixture. No customer data.CREATE TABLE calc.normalised ASSELECT account_id, raw_value / 100.0 AS normalised_valueFROM stg.readings;WHAT CAME OUT OF ITFIELDS READaccount_idraw_valueFIELDS OUTaccount_idnormalised_valueraw_valueTYPED OPERATORPROJECTraw_valueraw_valuecarried by nameSTRONGLY INFERREDaccount_idaccount_idas writtenDIRECTLY OBSERVEDraw_valuenormalised_valuedivided by a hundredDIRECTLY OBSERVEDWHERE THIS STATEMENT SITSAccount feed› Readings, as received› Readings, normalised› Daily report› Month-end totalbeyond this map
One normalising statement in its own six lines, and beside it what the reading takes from it: the fields it reads, the fields that come out of it, the typed operator the record names, each relationship with the grade the record gives it, and a strip marking where in the route this one statement sitsONE STATEMENT READTHE CODE AS WRITTEN02_normalise.sql-- Synthetic Theory fixture. No customer data.CREATE TABLE calc.normalised ASSELECT account_id, raw_value / 100.0 AS normalised_valueFROM stg.readings;WHAT CAME OUT OF ITFIELDS READaccount_idraw_valueFIELDS OUTaccount_idnormalised_valueraw_valueTYPED OPERATORPROJECTraw_valueraw_valuecarried by nameSTRONGLY INFERREDaccount_idaccount_idas writtenDIRECTLY OBSERVEDraw_valuenormalised_valuedivided by a hundredDIRECTLY OBSERVEDWHERE THIS STATEMENT SITS Account feed› Readings, as received› Readings, normalised› Daily report› Month-end totalbeyond this map

Synthetic Theory fixture. No customer data.

Nothing that came out of it is copied off the file. Each line of it is read out of the statement and written to the record, with the grade the source could carry.

Six relationships

See what a change reaches before you make it.

Change the normalising step and two steps downstream are reached. The evidence behind them is not equally strong.

The map traces a figure to the code that produces it, shows what a change can reach, and is regenerated when the code, its version or the reading's conditions change.

Six relationships from one small reading, each with the grade the record gives it, then the two steps one change reaches, the grade on each and the grade the record composes them atEVERY RELATIONSHIP AND ITS GRADERELATIONSHIPREADINGGRADERaw value into normalisingcarried by nameSTRONGLY INFERREDAccount id into normalisingas writtenDIRECTLY OBSERVEDRaw value to normalised valuedivided by a hundredDIRECTLY OBSERVEDAccount id into daily reportas writtenDIRECTLY OBSERVEDNormalised value into daily reportcarried by nameSTRONGLY INFERREDNormalised value to reported valueas writtenDIRECTLY OBSERVEDWHAT ONE CHANGE REACHESTwo steps downstream of the change, and the grade is not the same on both.The relationship that changedRaw value to normalised valueDIRECTLY OBSERVEDThe step it hands toNormalised value into daily reportSTRONGLY INFERREDComposed over the twoSTRONGLY INFERREDA composed path is no stronger than its weakest step.
Six relationships from one small reading, each with the grade the record gives it, then the two steps one change reaches, the grade on each and the grade the record composes them atRELATIONSHIPS AND GRADESRELATIONSHIPRaw value into normalisingcarried by nameSTRONGLY INFERREDAccount id into normalisingas writtenDIRECTLY OBSERVEDRaw value to normalised valuedivided by a hundredDIRECTLY OBSERVEDAccount id into daily reportas writtenDIRECTLY OBSERVEDNormalised value into daily reportcarried by nameSTRONGLY INFERREDNormalised value to reported valueas writtenDIRECTLY OBSERVEDWHAT ONE CHANGE REACHESTwo steps downstream of the change, and thegrade is not the same on both.The relationship that changedRaw value to normalised valueDIRECTLY OBSERVEDThe step it hands toNormalised value into daily reportSTRONGLY INFERREDComposed over the twoSTRONGLY INFERREDA composed path is no stronger than itsweakest step.

Four of these six are read out of an expression written in the statement.

The other two are read across a hand-over where no statement joins the two steps, so the only evidence is that the column name matches on both sides, and the grade says so.

Two columns can cross the same hand-over and be graded differently. The one an expression names is observed, and the one carried only by its name is inferred.

The four grades

What each grade means, shown on the specimen.

A grade says what the source could evidence for a relationship. Two of the four below are refusals, and they are rows in the same table as the other two.

The four grades with one worked specimen of each, read from the record: the expression the reading observed, the hand-over it inferred, the assembled statement it holds as not yet analysed with the reason kept beside it, and the launch that runs past the supplied sourceONE OF EACH GRADE FROM THE RECORDDIRECTLY OBSERVEDraw_value / 100.0The expression is written in the statement, so it is taken straight from the code.STRONGLY INFERREDNormalised value into daily reportThe two steps share the column name and no expression joins them, so the link is readacross the hand-over.NOT YET ANALYSED02_usp_month_end.sqlSET @sql = N'SELECT COUNT(*) FROM archive.month_end_' + @period;THE REASONThe procedure assembles one statement at runtime before it runs it.The reading records it as NOT YET ANALYSED and does not guess the table it would name.EXTERNAL04_boundary.batdtexec /f %PACKAGE_ROOT%\external_rate_lookup.dtsxbeyond this mapBeside a step that was directly observed, the record still shows the pair as theexternal one.The external word is refused a place in a composed path.
The four grades with one worked specimen of each, read from the record: the expression the reading observed, the hand-over it inferred, the assembled statement it holds as not yet analysed with the reason kept beside it, and the launch that runs past the supplied sourceONE OF EACH GRADEDIRECTLY OBSERVEDraw_value / 100.0The expression is written in the statement, soit is taken straight from the code.STRONGLY INFERREDNormalised value into daily reportThe two steps share the column name and noexpression joins them, so the link is readacross the hand-over.NOT YET ANALYSED02_usp_month_end.sqlSET @sql = N'SELECT COUNT(*) FROM archive.month_end_' + @period;THE REASONThe procedure assembles one statement at runtimebefore it runs it.The reading records it as NOT YET ANALYSED anddoes not guess the table it would name.EXTERNAL04_boundary.batdtexec /f %PACKAGE_ROOT%\external_rate_lookup.dtsxbeyond this mapBeside a step that was directly observed, therecord still shows the pair as the external one.The external word is refused a place in acomposed path.

How to read the standing.

  • DIRECTLY OBSERVEDResolved from the code as written: the expression, the declared binding, or an observed execution plan. Recorded as DETERMINISTIC evidence, or OBSERVED where the reading came from a captured execution plan.
  • STRONGLY INFERREDEstablished by converging signals across a hand-over between steps: here a column matched by name between the step that writes it and the step that reads it. Recorded as PROBABILISTIC evidence.
  • NOT YET ANALYSEDNothing has read it. The systems name it, no adapter reached it, and its internals are unknown because we have not looked. It carries no evidence grade: the reason is kept as a refusal, outside the grades.
  • EXTERNALDeclared at the boundary of the supplied source. What happens past it inherits the upstream system's guarantee. It carries no evidence grade, and low confidence never produces it.

The scale

It reads a whole codebase the same way.

This census is the engine's read of a real codebase, used as a test corpus of web pages, application code, database procedures and browser scripts.

It is a census of what was read and resolved. The codebase is a test corpus; its names are not published, and every figure on the drawing is read from the record it is bound to.

One mark for each of the 698 stages the census read, landing in four blocks sized by the record's own counts for web pages, application code, database procedures and browser scriptsA READ CENSUS OF A WHOLE CODEBASE419WEB PAGES186APPLICATION CODE49DATABASE PROCEDURES44BROWSER SCRIPTSSTAGES READ698
One mark for each of the 698 stages the census read, landing in four blocks sized by the record's own counts for web pages, application code, database procedures and browser scriptsA READ CENSUS OF A WHOLE CODEBASE419WEB PAGES186APPLICATION CODE49DATABASE PROCEDURES44BROWSER SCRIPTSSTAGES READ698

What comes back

Reporting is a framework you adjust.

One pass over the code, and what it found is held in one record. What is reported from that record is configured with you, so the reporting follows the way your organisation already works.

A register of your data says what somebody typed into it about each system.

A team putting a model or an agent over these systems can give it the record, which carries the map, the grade on each relationship and the refusals where the evidence ran out. The model then has, for each relationship, what the code established and its grade, and for each gap it has the refusal and its reason.

Every artefact is drawn from the same checked source reading.

Cosmogenesis reads the code your organisation runs on and derives from it what your systems do, so the register can say what exists, which part of it is critical and where it is at risk.

One record, eight shapes of it, and four things that decide what comes out.

  • Which shapes you take

    • Lineage record

      source route

    • Plain-English explanation

      checked wording

    • Critical-data-element map

      corroborated element

    • Finding register

      reviewable finding

    • Data dictionary

      business label

    • Change-impact brief

      bounded downstream set

    • CGS Docs

      source-linked scope

    • Evidence record

      checked reading

    Each is one shape of the same record. Which shapes you take, at which level and over what scope, is set with you at the start of the assessment.

  • What counts as critical

    Weights in configuration decide it, and the glossary, regulatory and risk-sensitivity factors carry nothing until yours supplies them. Change one and the answer changes, with no new release.

  • How far a report reaches

    Every asset, or one domain, or the reach of one report, or the critical elements only. Another control you set.

  • At which level

    Four levels, from column and table up to the condensed business graph, so one pass serves an auditor and a board.

  • What the target can carry

    Where a target system has no place to put an evidence grade, the export says so beside what it sends.

One real record is published. The read census is what was read and resolved over a test corpus of a real codebase, with every name replaced by a numbered placeholder, and it carries no grades. 70,702 bytes, SHA-256 15a98c4b. Open the census record

Next

Assess your use case.

A few questions return a bounded answer.

Only the code you supply is covered, so the map is as wide as the systems you hand over.