exist-db.org

NoSQL is an umbrella term for database systems that store and query data without the fixed table-and-row model of a relational database. You should consider one when your data shape varies a lot, when you need to spread writes across many machines, or when you are storing documents, key lookups, or highly connected records. You should stay with a relational database when your data is well structured, your queries depend on multi-table joins, and you need strong transactional guarantees across many records.

The main NoSQL families

"NoSQL" is not one technology. The four families below solve different problems, and choosing the wrong one is the most common mistake.

eXist-db, the project behind this site, is an example of a document-oriented, native XML database. Its own materials describe it as "a high-performance native XML database engine and all-in-one solution for building applications," and it is used for exactly the kind of variable-structure content that fits the document model: the U.S. Department of State's Office of the Historian uses it to let visitors "search and browse instantly through nearly a hundred thousand archival government documents," and the Tibetan Buddhist Resource Center describes a collection of "nearly 10 million scanned pages and over 11,000 Unicode Tibetan texts." Those are content-heavy, document-shaped workloads rather than ledger-style transactions.

How NoSQL differs from relational databases

The differences that matter in practice come down to four dimensions:

• Schema. Relational tables require a defined structure up front; changing it means migrations. Document and key-value stores usually let each record carry its own fields, which suits heterogeneous content but pushes validation into the application.
• Scaling. Relational systems typically scale up (bigger server) or rely on read replicas; many NoSQL systems are designed to scale out by partitioning data across nodes. That helps with write volume but adds operational work.
• Consistency. Relational databases generally give you strong, immediate consistency and multi-record transactions. Some NoSQL systems trade this for availability and partition tolerance, meaning reads can be eventually consistent. Check the specific product rather than assuming.
• Query language. SQL is standardized and join-friendly. NoSQL query interfaces vary widely—XQuery in eXist-db, JSON-style queries in document stores, traversal languages in graph databases—so skills and tooling do not transfer cleanly.

Matching a use case to a type

Use the following as a starting filter:

• Content and catalogs with uneven fields → document store. If your content is already XML (TEI, DocBook, archival metadata), a native XML database keeps the structure queryable instead of flattening it into columns.
• Fast single-key access → key-value store.
• Very high write throughput on semi-structured events → wide-column store.
• Questions that are really about relationships ("what links to what") → graph database.

For example, a digital humanities project with manuscript metadata, full texts, and cross-references is a document problem first and a graph problem second; a session store for a web app is a key-value problem and nothing more.

Trade-offs and pitfalls

• Joins get weaker. Cross-record relationships often move into application code or require denormalization, which can drift out of sync.
• Eventual consistency surprises. If a feature reads immediately after a write, confirm the product's consistency behavior before designing around it.
• Operational complexity. Distributed NoSQL systems need monitoring, backup, and partitioning decisions that a single relational server does not.
• Schema flexibility is not free. Without a schema, bad data enters silently; plan validation at the application or database layer.
• Licensing and cost. eXist-db states it is Open Source Software licensed under the LGPL; do not assume the same for other NoSQL products—verify each one.

A practical way to decide

Write down your three most important queries and your data's variability. If the queries are multi-table joins over stable fields, a relational database is the safer default. If the data is document-shaped and the queries are search-and-retrieve, start with a document store and confirm its query language covers your needs. If the queries are about connections, look at graph. Then prototype the hardest query first—that single test will tell you more than any feature comparison.

MESON is a free, online database of chess problems and endgame studies hosted on the BDS Website (bstephen.me.uk), run by Brian Stephenson. According to the site, it has been free and online since 2006 and currently contains more than 256,000 items. It is the right resource if you want to look up composed problems, search for a specific composer's work, or study endgame studies — rather than browse casual tactics puzzles.

What MESON actually contains

MESON is a chess problem database, not a game database. That distinction matters:

• Chess problems are composed positions with a stipulated task (for example, "mate in 2" or "mate in 3"), usually with a unique solution the composer designed.
• Endgame studies are composed endgame positions where the task is normally to win or draw, again with a constructed, often surprising solution.

The site describes MESON as containing "more than 256,000 items," covering this kind of composed material. It does not claim to be a record of played games, so don't expect opening statistics or tournament results here.

How to access it

Access is through the BDS Website's navigation menu:

1. Go to the BDS Website (bstephen.me.uk).
2. Select the MESON menu item.
3. You land in the database itself, where you can search and browse.

The site states MESON has been free and online since 2006. No pricing, account, or login requirement is mentioned in the available site information, so treat access as open browsing unless the site itself tells you otherwise when you arrive.

How to search for problems and studies

The site's own description does not spell out the search fields, so the practical approach is to work from what a problem database of this kind is built to answer. Typical ways to use it:

• By composer — if you already know whose problems you want (for example, work by a specific problemist), a composer search is the fastest route.
• By problem type or stipulation — mate-in-2, mate-in-3, helpmate, selfmate, study, and similar categories let you narrow to the genre you care about.
• By position — entering the pieces or a diagram position lets you find whether a given setting already exists, which is useful if you are checking a composition or studying a theme.

Because the exact field names and menu labels are not documented in the source material, verify them on the MESON search page itself rather than assuming a fixed layout. The database is implemented with MySQL and Perl (with CGI::Simple, HTML::Template and XML::LibXML) and a jQuery/Bootstrap/DataTables front end, which is consistent with a searchable, table-driven interface.

What else is on the BDS Website

MESON is one part of a larger site, and the surrounding sections are useful if you want context or related material:

If your interest is specifically endgame studies, the Endgame Studies menu and MESON together cover both the articles and the underlying positions.

Practical tips

• Start narrow. With 256,000+ items, searching by composer or stipulation first will get you to relevant material faster than browsing.
• Use the Ladder problems for practice. The BDS Ladder is closed as a competition, but the site keeps its problems available if you want solving practice.
• Check the composer's own page for context. Stephenson has composed and published problems since 1977, and his Chess Problems section is a small, curated complement to the much larger MESON collection.
• Contact route. The site points to the BCPS Website contact page, where Stephenson is listed as magazine curator, if you need to reach him.

MESON is best understood as a specialist reference for composed chess problems and studies: free, long-running, and large enough that targeted searching beats casual browsing.

Indie game development is the process of taking a game from an initial idea to a released, playable product with a small team or solo — typically covering concept, prototyping, production, and release. It suits developers who can wear multiple hats (design, code, art, audio, marketing) or who can collaborate with others to fill gaps. The practical core is scoping a project small enough to finish, choosing tools that match your skills and target platforms, and iterating based on real feedback rather than assumptions.

The Core Stages of Indie Development

Most indie projects move through four overlapping stages. They are not strictly linear — you will loop back as you learn — but each has a distinct goal.

1. Concept

Define the core loop: what the player does repeatedly, why it is fun, and what makes it distinct. Keep this to a one-page description. The output is a clear pitch you can test against.

2. Prototyping

Build the smallest playable version of the core loop. Use placeholder art and minimal systems. The goal is to answer "is this fun?" before investing in production. If the prototype is not engaging, change the concept rather than polishing it.

3. Production

Turn the validated prototype into a full game: real art, audio, levels, UI, save systems, and content. This is usually the longest stage and where scope discipline matters most.

4. Release

Prepare builds for your target platforms, handle store pages, ratings, and any platform-specific requirements, then ship and support the game with patches.

Choosing an Engine or Framework

The engine decision should follow your skills and target platforms, not trends. A rough guide:

Match the tool to what you can actually finish with. A powerful engine you do not understand slows you down more than a simple one you do.

Essential Tools for a Small Team

Beyond the engine, indie developers typically rely on a small set of supporting tools:

• Code editor / IDE — whatever you are productive in; the site's own keywords include editors like Neovim and Vim, which are common among developers who prefer keyboard-driven workflows.
• Art tools — 2D raster or vector editors, or 3D modeling software depending on your style.
• Audio tools — for sound effects and music, or sources for licensed assets.
• Version control — essential even solo. It lets you experiment safely and recover from mistakes.
• Project tracking — a simple task list or board to keep scope visible.

The exact products matter less than having one tool per job and sticking with it.

Scoping a First Project

The most common reason indie projects fail is scope, not skill. A finishable first project usually:

• Has one core mechanic, not five.
• Can be completed in a few months of part-time work.
• Uses a visual style you can produce consistently.
• Has a clear end state (a win condition, a final level, a credits screen).

Test scope by asking: can I describe the entire game in one sentence, and can I build a playable version of that sentence this month? If not, cut until you can.

Common Pitfalls

• Feature creep — adding mechanics mid-production. Freeze the design after prototyping and log new ideas for a sequel.
• Asset licensing — if you use third-party art, audio, or code, verify the license permits your intended use, including commercial release. CC0 assets are a common starting point, but always confirm the terms yourself.
• Platform requirements — stores and consoles have technical and content rules. Check them before you are deep into production, not at submission.
• No feedback loop — building in isolation until launch. Share early builds to catch problems while they are cheap to fix.

Communities, Feedback, and Distribution

Indie development is solo-friendly but not isolation-friendly. Useful entry points:

• Developer communities and forums — for technical help and design critique.
• Playtesting groups — for structured feedback on builds.
• Distribution channels — storefronts and platforms where indie games are commonly published; each has its own submission and revenue terms you should read directly.

Start with one community and one distribution channel, learn their norms, and expand only when you have something to show.

A Practical Starting Path

1. Write a one-page concept with a single core loop.
2. Build a placeholder prototype and test whether it is fun.
3. Pick an engine or framework that fits your skills and platforms.
4. Set up version control and a simple task list.
5. Freeze scope, produce the game, and playtest regularly.
6. Prepare platform requirements early, then release and patch.

The through-line is finishing: a small, complete game teaches more than an ambitious unfinished one.

XQuery is a query and transformation language for XML data. You use it to select, filter, reshape, and combine XML documents, and to build XML-backed applications when it runs inside an XML database such as eXist-db. It is the right tool when your data is XML (or XML-like, such as TEI, DocBook, or metadata records) and you need to search and restructure it rather than just store it. If your data lives in relational tables, SQL is the more direct fit.

What XQuery does

XQuery is standardized by the W3C and is deliberately expression-oriented: almost everything returns a value, and values are sequences of XML nodes or atomic items. That single idea covers the main jobs:

• Querying: find documents or fragments matching conditions, similar to how SQL filters rows.
• Transforming: convert one XML vocabulary into another (for example, TEI manuscripts into HTML pages).
• Constructing: build new XML directly in the query, which is how XQuery produces output for web pages and reports.
• Combining: join and merge data from multiple documents or collections in one expression.

A minimal example shows the shape of the language. Given a collection of <book> elements, this returns the titles of books published after 2000, wrapped in a new element:

<recent>
  {
    for $b in collection("/db/books")//book
    where $b/year > 2000
    order by $b/title
    return <title>{ $b/title/text() }</title>
  }
</recent>

The for/where/order by/return clause is the workhorse pattern. The curly braces switch from constructing XML into evaluating an expression, which is why XQuery can both query and generate markup in the same statement.

How XQuery differs from SQL and general-purpose languages

XQuery is not a replacement for a general-purpose language. In practice it handles the data-access and transformation layer, and a host language or the database's own HTTP layer handles the rest.

How XQuery relates to eXist-db

eXist-db is an open-source native XML database, licensed under the LGPL, that stores XML documents and executes XQuery against them. In that setting XQuery is not just a query tool but the application language: you can write queries that read stored documents and return HTML, which is how eXist-db supports full-stack XML web application development.

The project's own materials show this pattern in real deployments. The U.S. Department of State's Office of the Historian uses eXist-db to power a public website where visitors search and browse nearly a hundred thousand archival government documents. The Tibetan Buddhist Resource Center describes holding nearly 10 million scanned pages and over 11,000 Unicode Tibetan texts with online access for over 4,000 users. The University of Victoria Humanities Computing and Media Centre reports using eXist-db across a dozen or more projects. These are document-centric, search-heavy workloads, which is exactly where XQuery plus an XML database fits.

Where to start

1. Learn the language basics first: path expressions, FLWOR expressions (for, let, where, order by, return), and element constructors. These cover most day-to-day queries.
2. Get a place to run queries. eXist-db is one option; its site provides documentation and downloads, and the download page is the entry point for installing it locally.
3. Practice on real XML. Take a small set of documents in a vocabulary you care about (TEI, DocBook, RSS) and write queries that filter and reshape them. This is faster than abstract exercises.
4. Move to application patterns once queries are comfortable: returning HTML from queries, and organizing stored documents into collections.

A common sticking point is expecting SQL-style thinking. XQuery works on ordered, nested sequences, so "joining" often means iterating over one document set and looking up related nodes in another, and results keep document order unless you sort explicitly. Another is forgetting that constructed XML and computed values are different things; the curly-brace syntax is what bridges them.

eXist-db is an open-source, native XML database engine that stores, indexes, and queries XML documents directly, using XQuery as its primary query language. It is best suited to projects where the data is already XML or XML-derived — document archives, digital humanities collections, TEI-encoded texts, publishing platforms — and where you want the database and the application layer to work with the same data model. It is licensed under the LGPL and is available for download from exist-db.org. If your data is primarily tabular and relational, a relational database will usually be the simpler choice.

What "native XML database" means

A native XML database does not shred XML into tables or map it onto a generic document store with XML bolted on. The XML document is the unit of storage, and the tree structure of elements and attributes is what gets indexed and traversed.

That has two practical consequences:

• Queries follow document structure. You write XQuery path expressions against elements and attributes rather than reconstructing joins across tables.
• Round-tripping is lossless. What you store is what you get back, including mixed content, namespaces, and document order — details that matter for scholarly and archival texts.

eXist-db pairs this storage model with an XQuery engine and support for the surrounding XML stack, including XSLT and XForms. The project describes itself as an "all-in-one solution for application building," meaning the database, query engine, and web application layer can live in one server.

What it is used for

The published user accounts on the project site cluster around a few recognizable patterns:

The common thread: content that is structured as documents, needs to be searched and browsed by users, and benefits from being queried and transformed with XML tooling rather than reassembled from relational rows.

How it differs from relational and general NoSQL databases

• Versus relational databases: no schema-to-table mapping step, no impedance mismatch between document structure and storage. The trade-off is that set-based reporting across highly uniform records is often more natural in SQL.
• Versus general document stores: eXist-db is built around XML standards specifically — XQuery, XSLT, XForms, namespaces, XPath — rather than JSON-first APIs. If your content is JSON, a JSON-native store is the more direct fit; if it is XML or TEI, eXist-db avoids a conversion layer.
• Versus a search engine alone: it is a database with indexing and query, not only a full-text index, so it can hold the authoritative copy of the documents as well as serve search over them.

How to evaluate it for your project

1. Download eXist-db from the Download section of exist-db.org and start the server locally.
2. Load a representative sample of your own XML — a few hundred documents is enough to test structure and query patterns.
3. Write the queries your application actually needs in XQuery: browse-by-structure, full-text search, and any transformations to HTML or other output formats.
4. Check the application layer. If you need a web front end, confirm that the built-in application approach and XForms/XSLT support match your team's skills.
5. Read the documentation and screencasts on the site, and look at the showcased projects closest to your use case before committing.

Common sticking points to plan for: XQuery is a different mental model from SQL and takes ramp-up time; teams without XML experience will need to learn the stack; and if your data arrives as CSV or JSON, you should decide up front whether converting to XML is worth it.

The project's own references — a national archive, a large canon of Tibetan texts, university humanities centers, and a medical publishing platform — are a reasonable proxy for where it fits: document-centric, standards-based, search-heavy applications. For transactional business data with heavy relational integrity requirements, look elsewhere.