Skip to main content

44 posts tagged with "Blong"

The framework itself — how it is shaped and why.

View All Tags

Stop writing log messages, declare events

· 4 min read
Kalin Krustev
Author of Blong

Every logging library in the last twenty years lets the call site write the sentence. That one decision — the message is composed where the event happens — has quietly cost us three things: identity that moves when nobody changed behaviour, alerting that breaks on a reworded line, and configuration that can only ever speak in levels for a whole service.

lukaot moves the sentence to a declaration beside the code, and the call site names it. The result is one vocabulary with four kinds — a line, an error, a payload, a decision — and an identity that exists before the process starts.

One path, two protocols

· 6 min read
Kalin Krustev
Author of Blong

A chat bot is the smallest integration that is not small. The platform calls you, you call it back, a person has to answer a question inside the conversation, and the credential that makes any of it work expires while the process is idle. Slack and Viber disagree about almost every detail of that and agree on nothing about the words they use for it.

The blong-chat realm is the proof that one adapter can carry all of it: one URL for both halves of the conversation, one method the realm answers, and a process that maintains its own Slack app from a database rather than from a config file a person edits by hand.

Point at what is wrong

· 5 min read
Kalin Krustev
Author of Blong

The cheapest bug report a person can write is a sentence and a circle. What arrives instead is a screenshot and "the header is cut off on narrow screens" — and then whoever fixes it searches the codebase for a table that might be the table in the picture. If they pick the wrong one, the report comes back.

The picture and the sentence are fine. What is missing is which element, said in a way a program can act on. Pixels cannot say it, a CSS selector rots as soon as the layout changes, and an array index is not an identity.

Blong's feedback mode lets a person point at the element in the running application, and records the element as the path the application itself uses: the page, then one step per container.

Watch the test run in the browser

· 4 min read
Kalin Krustev
Author of Blong

A failing test gives you a stack trace and a line number. It does not give you the twelve steps that ran before it, the value two of them passed along, or the branch that was taken three calls earlier. So the first debugging session is usually a re-run with print statements — the same information, paid for twice.

Blong's Test runs console starts the run from inside the portal and shows it while it happens. The steps are a timeline, the dependencies are a graph, and every assertion sits beside the value the step returned. The console is a page in the application, not a separate report.

The Storybook in the page

· 5 min read
Kalin Krustev
Author of Blong

A page in these docs has always been able to describe a screen. The Storybook next door could always show it. This week the two moved in together: the Storybooks are published with the documentation, and a page embeds a story the way it embeds a picture.

<StorybookStory
site="browser"
id="editor--toolbar"
title="The Editor's toolbar"
/>

That is a real call, and this is its result:

Editor/Toolbar — the toolbar story, running in this pageOpen in Storybook

A cluster shaped like your code

· 6 min read
Kalin Krustev
Author of Blong

A Blong suite already knows what it is: which realms loaded, which layers registered, which orchestrator namespaces were claimed. So we stopped writing that down a second time and made the deployment read it.

cd suite/blong-suite && blong ./index.ts k8s

That writes the repository half of system/kustomize/ — Deployments, Services, volumes, RBAC — and exits; the declaration rides beside it as example/, because which suite a namespace runs is the tenant's decision rather than the repository's. Nothing was configured to say which layer belongs to which process, because the answer was already in the registry.

The other half belongs to the deployment. A second run over the same registry, given the values this cluster owns — the namespaces, the artifact's identity, the credentials the deployment declares — writes local/ beside the base, and kubectl apply -k system/kustomize/local composes the two. Only the base is committed: it is what a reader compares between two revisions, while the overlay is what changes between two deploys.

The repo answers by meaning

· 7 min read
Kalin Krustev
Author of Blong

A friction entry is written in the words of the problem, and it is read months later by somebody recalling a situation rather than a phrase. The two rarely match. F-325 is titled A cached stats read made a finished ingest look stuck; the question that should find it sounds more like "the summary endpoint kept reporting work as outstanding after the log said it was done". What the entry and the question share is the situation, and a text search cannot see it.

The previous post was about the notes themselves — markdown, ids, one command that owns their format. This one is about what now sits beside them: an index the same command feeds as it writes, and a search that takes a question in your own words.

The Storybook toolbar reaches a real backend

· 7 min read
Kalin Krustev
Author of Blong

A Storybook story is the cheapest place to look at a screen and the most expensive place to trust one. The model page renders perfectly in the story, and in the application it fails — because the story's rows came from a fixture file and the gateway method the page calls does not exist. The toolbar that used to solve this in the previous, webpack-based setup has been rebuilt for Blong's Vite Storybook, and a realm now gets it in one line:

export default defineBlongStorybookPreview(browser, {backend: true});

That line brings five toolbar items — Backend, Role, Theme, Language, Direction — and the machinery behind them. This post is about the two interesting ones.

The test tells you how far it got

· 5 min read
Kalin Krustev
Author of Blong

A failing test that says expected true, got false is a puzzle. It tells you the assertion, not the journey: which step of twelve ran, which branch was taken, what the values were when the decision was made. So the first thing anybody does with a red build is re-run it locally with print statements — paying for the same information twice.

Blong's handlers can announce where they are. A checkpoint is a named moment with data; a decision is a branch with its candidates. Both travel with the work, both reach the report, and both are free in production — which is what makes them worth writing into the code rather than into a test.

Draw the sequence diagram from what actually ran

· 6 min read
Kalin Krustev
Author of Blong

Every architecture diagram in a wiki is wrong. Not because anybody was careless, but because a diagram is a claim about what the code does, written by hand, and the code moves. The picture that survives is the one that is generated from a run — and generating it needs records that carry more than a message.

Semantic logging carries exactly enough: the leg each call belongs to, the checkpoints a handler passed, and the branches its decisions took. From those, a sequence diagram of a real execution falls out — and the interesting part is not that it can be drawn, it is what a reader can tell from it.

Record-level ACL that can only narrow

· 6 min read
Kalin Krustev
Author of Blong

RBAC answers "may this caller call this method". It has one blind spot, and everybody meets it the first time a customer service user opens a list and sees every customer in the company: the method is allowed, and the records are all of them.

An access-control list closes that gap without touching the method check. It is opt-in per table, evaluated in SQL as part of the query, and it can only ever take permission away — which is the property that makes it safe to add to a running system.

Roles as bits in the token

· 5 min read
Kalin Krustev
Author of Blong

Start with a number, because the number is the idea. A role in Blong is a bit, numbered 0 to 1023. A caller holds a set of them, the signed token carries that set as a base64 bitmask under the per claim, and the gateway answers "may this caller invoke this method?" without asking a database anything.

Six roles in a development database look like this — the bit beside the name, and the mask the login hands out:

access_role: 0 Admin · 1 Manager · 2 Customer Service · 3 Customer · 4 Guest · 5 NoLogin
access.user → per: testAdmin [0] AQ== testViewer [3] CA== testGuest [4] EA== testNoLogin [5] IA==

AQ== is one byte with bit 0 set. CA== is bit 3. The claim is the whole authorization payload a request carries, and it travels in a header rather than in a session lookup — which is what makes the check cheap, and what makes revocation a separate problem that sessions exist to solve.

The repo remembers what cost effort

· 7 min read
Kalin Krustev
Author of Blong

Every team discovers the same thing about its own bug tracker: the useful knowledge is not in the ticket, it is in the comment where somebody says what they tried, why it did not work, and what they did instead. That comment is usually the last thing written and the first thing lost, and the next person pays for the same afternoon all over again.

This repository keeps that kind of note in the repository, in markdown, under three headings — frictions, todos and decisions — written through a command that owns their format. It is deliberately not a tracker. It is the smallest thing that makes a note citable, greppable and verifiable, and it exists because a coding agent's session starts with no memory at all.

One sticky comment for the whole monorepo

· 6 min read
Kalin Krustev
Author of Blong

A monorepo of forty packages that each report their own results produces a specific kind of unusable CI. The check is green and nobody believes it. The logs are thorough and nobody reads them. And the one question a reviewer actually has — "did this branch break that test, or was it already broken?" — has no answer anywhere in the run, because answering it needs a comparison nobody made.

Blong's answer is one document. Per package it carries the counts, the duration, the coverage and the change against the base branch; for the run it carries the tests that did not run, the slowest test, and every failure with its provenance. That same document is the artefact and the pull-request comment, so there is nothing to reconcile.

The log line that knows its own structure

· 8 min read
Kalin Krustev
Author of Blong

A log line is a sentence with a timestamp stapled to it, and everything that has gone wrong with production observability follows from that. Two runs of the same code produce two different strings, because one of them transferred 1001 and the other 9876 — so nothing can be counted, nothing can be compared, and the only thing that scales is a search that scales with your bill. Then the incident arrives and the line you need is the one that was never written, because writing it would have meant logging a customer's balance.

Semantic logging is an attempt to fix both ends at once: mask the values, hash what is left into a template that is the same on every occurrence, mint an identity for the record locally, and ship the structure rather than the text.

One component library, several visual identities

· 6 min read
Kalin Krustev
Author of Blong

The usual way to give a product a second look is to fork the components. It works, and it costs a second copy of every bug fix: the design changes the theme, the theme needs a component to behave slightly differently, and from that point on there are two editors, two tables and two places to fix the keyboard handling.

Blong keeps one component library and gives it more than one visual identity. A theme names the identity; the identity itself is a scoped stylesheet plus, where the look needs them, generated textures. The same coral editor renders on three different surfaces without a component knowing which one it is on.

The same editor page in the glass variant

The same editor page in the wood variant

Kukum: the framework generates its own primitives

· 7 min read
Kalin Krustev
Author of Blong

Every framework with a strong convention ends up documenting that convention twice. Once as prose — "a handler file is named subjectObjectPredicate, it exports the same name, it forwards $meta" — and once as the skeleton somebody pastes from the last file they wrote. The prose drifts from the code, the skeleton drifts from the prose, and the person following either one finds out which by compiling.

Blong moved the skeletons into the framework. There is now an API that writes a primitive on request, validates the name before anything reaches disk, and can tell you what is already wired up in the process you are talking to. It is called kukum, and it is the answer to a question the skills used to answer in prose.

One admin UI for every backend

· 6 min read
Kalin Krustev
Author of Blong

Count the backends a normal system depends on. A relational database for the data, a bucket for the files, a key-value store for the cache, a queue for the events, a secret store for the credentials, a directory for the users, and a cluster running all of it. Then count the screens: one per backend, each with a slightly different table, a slightly different filter box and the same four bugs.

The commander realm describes each of those as a source — a namespace of triples with levels — and renders all of them with one explorer. The screens disappear; what remains is a descriptor per backend and, where the connection needs one, a small adapter.

Every configured source in one tree — Kubernetes, S3, Vault, Mongo, Redis, Kafka, Keycloak and the SQL database

Sessions, refresh tokens and audit

· 6 min read
Kalin Krustev
Author of Blong

A signed token is a lovely thing right up to the moment you need to take it back. It cannot be revoked, it says what it said when it was minted, and it stays valid until it expires — which is why "stateless JWTs" and "we need to log this user out" cannot both be true without a second mechanism underneath.

Blong's answer keeps the token as the fast path and adds a database-backed session behind it, with rotation, inactivity, revocation, and an audit trail written at the one place every controlled operation passes through.

blong-dev: the dev loop in one CLI

· 7 min read
Kalin Krustev
Author of Blong

Every codebase accumulates a directory of shell scripts, and every one of them starts as a good idea. load-db.sh because the connection string was long. read-log.sh because the logs only existed in a terminal that had already been closed. open-trace.sh because a Playwright trace is a zip of JSON lines and reading it by hand is a tax on every failure. Each script is correct on the machine of the person who wrote it, and none of them is documented anywhere a new contributor would look.

Blong puts that directory in one command, and the reason it is worth a post is not the count of subcommands — it is that the commands are shared by the two kinds of caller this repository has: a person at a terminal, and a coding agent working through the same loop.

blong-dev lint [files...] Run tsc + cspell + eslint in current package
blong-dev lint-staged Lint git staged files across all affected packages
blong-dev test Run tap tests in current package
blong-dev report vitest Convert coverage/vitest.json into .ci-report/
blong-dev ci-report Aggregate .ci-report/ into the CI report
blong-dev playwright [args] Run Playwright tests in current package
blong-dev proxy [opts] MLE proxy for curl (--port/--target/--username/--password)
blong-dev trace <trace.zip> Print a human-readable Playwright trace timeline
blong-dev log [ulid] [opts] Fetch log entries from cacache (--output/--level/--search/...)
blong-dev sql [opts] Run a SQL query via .blong_devrc (--output json|pretty)
blong-dev memory <verb> Add, list, show, close, format or check agent memory entries
blong-dev docs <verb> List, generate, check or verify the docs site artefacts

One graph for the whole domain

· 6 min read
Kalin Krustev
Author of Blong

Ask a system of any age a simple question — "which organisations is this person connected to?" — and you can watch it fail in a specific way. The person exists three times: once in the HR tables, once in the customer records, once in the login store, and the three rows share a name and nothing else. The connections are worse: a membership is a join table here, a foreign key there, a JSON array in the third place, and no query can follow the chain without knowing which of them it is standing in.

Blong puts people, organisations, units, roles, users and actions in one graph. An entity is a resource; a relationship is an edge between two resources; and the realms that describe them are lenses over that graph rather than separate stores standing beside it.

No migration files

· 6 min read
Kalin Krustev
Author of Blong

Every migration directory carries the same three problems, and nobody who has maintained one for a few years still argues about them. The files are ordered, so the order matters and a merge can put two of them side by side. The history is append-only, so the schema you have is the sum of everything ever written rather than a description of what is wanted. And the DDL that stores a record is written twice — once in a migration, once in the validation that accepts the request — so the two drift the first time somebody adds a field on one side only.

Blong deletes the second description and the ordering problem with it. The TypeBox object a handler already uses to validate its input is the table. There is no migration directory, no version table and no numbered prefix to invent.

Full-stack tests that log in for you

· 6 min read
Kalin Krustev
Author of Blong

Read a hundred browser tests from a system that has been running for a few years and most of them are not about the product. They are about the plumbing: a helper that signs in, a helper that navigates to the right page, a helper that waits for the table to fill, and — the one that hurts — a copy of the field names, so that the day a form is redesigned, forty tests fail for a reason unrelated to the feature each one was protecting.

Blong's Playwright layer takes that plumbing away and puts a floor under it, so a test file is close to a statement of intent. The fixtures log in; the CRUD helpers find the page, its widgets and its fields from the model the server already declares; and the primary assertion is a picture rather than a selector.

A UI generated from the schema

· 5 min read
Kalin Krustev
Author of Blong

Every framework that generates CRUD screens eventually meets the same objection: the generated page is never quite the page you need, so you write it by hand — and then the entity has two descriptions, a server-side one that validates and a client-side one that renders, which drift apart the first time somebody adds a field.

Blong answers by removing the second description. The type written for a handler is the model: it validates the request at the edge, creates the table that stores it, appears in the API document, and is what a generated form reads. A page is a declaration on top of that, not a parallel universe.

Templates you do not trust

· 5 min read
Kalin Krustev
Author of Blong

A template engine is a small feature with a large security surface. The moment the text being rendered is not yours — a tenant's notification, a partner's message, a row somebody edited in an admin screen — the template is untrusted code, and "render this string with these variables" is a sentence that has ended more than one product.

The interesting part of Blong's template engine is not that it renders ${name}. It is that the API has two modes, and the choice between them is a statement about where the template came from.

Pin the picture, not the implementation

· 5 min read
Kalin Krustev
Author of Blong

Assertions are cheap to write and expensive to keep. A test that checks four fields of a response is four lines, and the fifth field — the one nobody thought to check — is the one that breaks in production. Multiply that by every handler in a framework and the test suite becomes a description of what the code used to do, maintained by hand, field by field.

Snapshot testing inverts it: capture the output once, commit it, and let a diff be the review. The discipline is in what you capture and how narrowly, and that is what this post is about.

Intents: one word that picks the topology

· 5 min read
Kalin Krustev
Author of Blong

Most projects decide at build time what they are deploying. The web build gets the browser entry point, the service build gets the server one, the test build gets the mocks, and the differences between them live in environment files, build flags and a README about which command to run where. The topology becomes a property of the artefact, and the artefact has to be rebuilt to change it.

In Blong the topology is a word on the command line, and the code is the same code.

blong # dev + microservice + integration
blong integration blong-access.adapter # the access realm's adapter, as a test target
blong prod # the same realm, as a service
blong db # create and seed, then exit

Widgets, editor, explorer, master-detail

· 6 min read
Kalin Krustev
Author of Blong

A generated form is easy to demo and hard to live with. The demo shows a text field appearing from a schema; the thing that decides whether the generator is useful is what happens when a field needs a different control, when one field has to influence another, when a record owns a list of children, or when the same data has to be edited as a permission matrix. Those are the cases where a generator either has an answer or sends you back to hand-written pages.

Blong's answers are all declared in the same place the page comes from: the widget a field gets, the method a widget may call back, the children a record owns, and the rows a matrix starts from.

Portal, app, login and a second language

· 5 min read
Kalin Krustev
Author of Blong

A UI framework has a decision to make long before it renders anything: how much of the application does it own? Own too little and every realm re-invents a menubar, a login page and a place to put state; own too much and a realm that wants a different shell has to fight the framework to get one.

Blong's browser realm answers with a stack of four levels, each of which can be replaced, and with one small convention that keeps translation from being a second vocabulary everybody has to learn.

Point Blong at a folder and run

· 5 min read
Kalin Krustev
Author of Blong

Most frameworks ask for a project before they will do anything: a manifest, an entry point, a directory layout the tool recognises. The generator that produces it is the first thing you learn and the first thing that goes stale, and it decides for you what a "project" is.

Blong's answer inverts that. A folder with a couple of handler files in it is a server — and if a suite names a realm whose folder does not exist, the folder is created from the template on the spot.

Change the config, keep the process

· 5 min read
Kalin Krustev
Author of Blong

Configuration is the one part of a running system that everybody edits and nobody enjoys restarting. A connection string, a timeout, a feature switch: the value is a line in a file, and the cost of changing it is a process that drops every connection it was holding. So the value stays wrong until the next deploy, and the deploy is scheduled for something else.

Blong treats the merged configuration as a live object: edit a watched file and the process re-reads it, diffs it against what it had, and swaps it in — without restarting, and without a request ever seeing half of the change.

A realm's filesystem in your editor

· 4 min read
Kalin Krustev
Author of Blong

There is a specific kind of support request that every deployed system generates: something is wrong in a running environment, the fix is one file, and the file is on a server you are not supposed to log into. So you describe the file to a colleague who has access, they describe it back, and eventually someone edits it over a shell with three terminal windows open and no way to see the diff.

The last post in this arc is about removing that trip. The framework can serve a folder over HTTP, and a VS Code extension implements a filesystem on top of it — the explorer opens the running realm's tree, the file is edited where it lives, and a command runs on the server with its output streamed back.

Gherkin as the test source

· 8 min read
Kalin Krustev
Author of Blong

The oldest argument in testing is whether the specification or the test is the source of truth. When they are two artifacts, the answer is neither: the specification describes what the system should do, the test asserts what it does, and the difference between them is discovered in production. When they are one artifact, the question disappears.

In Blong that artifact is a Gherkin scenario, parsed by the real @cucumber/gherkin parser and compiled into the same chain steps every other test uses. A business rule and its automated check are one file that a domain expert can read.

Enterprise integration patterns as handlers

· 4 min read
Kalin Krustev
Author of Blong

Enterprise Integration Patterns are usually a framework you adopt: you import a DSL, declare routes in its vocabulary, and your business code learns to speak that vocabulary. It works, but the routing decision now lives in a language the rest of the codebase does not use, and replacing one destination with a test double means understanding the framework's lifecycle.

In Blong a pattern is not a framework — it is a handler. One file, a few lines, calling other handlers by name through the proxy. The pattern shows up as the shape of the function, not as a dependency.

Mock, sim or real

· 6 min read
Kalin Krustev
Author of Blong

Every test suite decides how much of reality it is willing to pay for, and most suites make that decision by accident: the first test reaches for a real database because it was there, the next one stubs a client because the real one was slow, and two years later nobody can say what the suite actually proves. The tests pass; the question "would this catch it?" has no answer.

Blong has three levels of backend fidelity, and the difference between them is what each one can prove. What matters is that the level is chosen by the environment — the same test, unchanged, runs at all three.

Real backends in CI, in a throwaway cluster

· 6 min read
Kalin Krustev
Author of Blong

There is a class of bug that no amount of testing discipline catches, because it is not in your code. MySQL under concurrent writes takes a lock nobody expected; a broker rebalances while you are consuming; a token refresh races the request that needed it. A mock will never find these, and a simulator will never find these — they exist only where two real systems meet.

The usual answer is a shared staging environment, which is either stale, contended, or both. This is how Blong runs those tests instead: provision the real back ends into a cluster that lives exactly as long as the job, publish their ports to the runner, and let the suites connect as if the services were local.

A layer that describes itself

· 4 min read
Kalin Krustev
Author of Blong

Every framework starts with an entry point that wires things up, and that entry point is honest for about a year. Then an adapter grows a development URL, the orchestrator needs a namespace, a production deployment wants different credentials, and the file that was supposed to list components becomes the place where every component's configuration is written down — by someone who has to hold the whole component in their head to do it.

Blong moves that configuration into the component. A layer declares when it is active and what configuration it accepts, in its own file, next to the code it configures. The realm's entry point goes back to being a list of children.

Watch every process from one browser tab

· 5 min read
Kalin Krustev
Author of Blong

A development run of Blong is never one process. There is a gateway, one or more realms, a browser bundle, a test run replaying the bug — each with its own terminal, each interleaved with hot-reload noise. The one line you need is somewhere in the middle of one of those windows, and the trace id that would tie the story together is buried inside it.

So we stopped tailing terminals. Every process ships its entries to one small server, and the server fans them out to a viewer in a browser tab. The tab is the log.

Errors as a proxy

· 6 min read
Kalin Krustev
Author of Blong

Almost every framework says its errors are typed. What that usually means is that an error class exists somewhere, and every code path that raises it imports it, constructs it and hopes the message matches what the documentation promised. The definition and the call site drift apart, and the drift is invisible until a client reads a message that no longer describes the failure.

In Blong an error is data with a namespaced type, declared once in a realm's error layer, and reached from a handler through a proxy — no import, no constructor, no factory wiring, and a typo that fails before the function runs.

A test that finds its own parallelism

· 5 min read
Kalin Krustev
Author of Blong

A test is a story, and stories are linear. So test code is linear: set up a user, then fetch the account, then build the report, then assert. The runner then executes that story one line at a time, and a suite of such stories takes as long as the sum of everything in it — even though the four lines that set up four unrelated fixtures had no reason to wait for one another.

The usual fixes are both unsatisfying. You can declare the dependencies by hand and watch the declarations rot as the test changes, or you can run everything concurrently and watch the suite fail in ways that depend on timing. Blong took the third option: the executor discovers the dependencies from the test's own data flow and parallelises everything the data flow permits.

The name is the API

· 5 min read
Kalin Krustev
Author of Blong

Every framework has a naming convention. Almost none of them check whether you followed it, and none of them can tell you what a function does without reading its body. In Blong a handler's name is not documentation about the code — it is the API. The file the code lives in, the function it exports, the method the network carries, the URL that reaches it and the row that appears in the generated documentation are all the same string.

That single decision is why the framework can generate a routing table, a validation schema and an API document without being told anything twice — and why it can reject a name that disagrees with itself instead of quietly publishing it.

The pipeline that releases the framework

· 6 min read
Kalin Krustev
Author of Blong

Releasing a framework is a different job from releasing an application. An application ships once and the version belongs to a deployment; a framework is consumed by other people's builds, so every published version is a promise that has to hold for strangers, and the promise has to be attributable when it breaks. The repository has to answer three questions without a human remembering anything: what changed, what version does that make, and can a consumer prove the artifact came from this commit.

In January we replaced a manual, change-file-driven release with a pipeline where the version is a consequence of the merge and the artifacts are attested. The commit that did it is called fix: prepare for publishing, and it deleted more than it added.

Every external system behind one adapter API

· 5 min read
Kalin Krustev
Author of Blong

Every external system arrives with its own habits. A Kubernetes watch stream never "returns", a Vault token expires, S3 wants a bucket and a key before it will talk, Kafka hands you a consumer group you did not ask for, and Redis speaks Lua when you want the answer to be atomic. Integration code is where those habits leak into a codebase — a client here, a credential there, an SDK call in the middle of a business rule.

Blong's answer is to make them all look the same. Kubernetes, Keycloak, S3, Vault, Slack, GitHub, SQL, MongoDB, Kafka and Redis reach the rest of the framework as one thing: a handler that answers a semantic triple.

Blong

· One min read
Kalin Krustev
Author of Blong

I am happy to announce the release of Blong 2024, codename Ambrym.

This framework is the result of many years of efforts around producing reusable software.