As it turns out, this is quite a difficult question to answer. The problem lies in the wide audience that eXist serves. eXist is many things to many people, and thus there is no single succinct answer.
eXist is an open source piece of software written in Java that is freely available in both source code and binary form. eXist has always been made available under the Lesser GNU Public License (LGPL), version 2.1. While eXist makes use of many other open source libraries itself, all of these are compatible with the LGPL, and eXist eschews the GPL license in favor of freedom of choice for its users.
eXist was conceived as a native XML database. As a database, its unit of atomicity is the document, so we could very easily brand it a NoSQL document database. However, to do so would be to do an injustice to the software, and worse, to all of those who have contributed to making eXist much more than just a NoSQL database over the years.
Unlike most NoSQL databases, which each have their own proprietary database query language, eXist makes use of a standardized query language developed by the W3C: XML Query Language (XQuery). With a standard query language, you have the ability to write code that can be used not just on eXist, but on any platform or processor that supports XQuery. Some of the benefits of XQuery are that it is:
XQuery was carefully designed and evolved over a six-year period by an open working group with many contributors, meaning that many real industry use cases were considered during its construction. XQuery has been influenced by several previous languages and concepts, such as Perl, Lisp, Haskell, SQL, and many more.
XQuery was designed to be simple to use and debug, meaning that nonprogrammers (given an understanding of their documents) should be able to easily construct queries. Many eXist users work in the humanities and have no formal computer science background, but are quite comfortable writing complex XQueries to query their documents.
The XQuery specification does not detail how an implementation should perform query processing, and its developers have given great thought to ensuring that any implementation can optimize processing of query operations. Likewise, as a moderate user of XQuery, you can often easily understand why a particular query is slow and what you may do to improve it.
Join operations in XQuery (e.g., predicates and
where clauses) lend themselves well to
index optimization, which eXist exploits to speed up XQuery
execution. eXist provides multiple indexing schemes that the user
XQuery is more than just a query language: it is in a class of languages known as Turing complete, which means that it is a complete programming language and any program can be expressed in it. XQuery is also a functional programming language, as opposed to a procedural one, meaning that it is generally easier to construct programs that you can easily understand and that ultimately contain fewer bugs. In eXist you can build entire applications in just XQuery!
While XQuery is a programming language, it is designed primarily as a query language. Therefore, it is much easier to extract just a few elements from large data collections with XQuery than, say, with XSLT.
While XQuery is easy to get started with, its functional nature can make it tricky to work with if you have only procedural programming experience. XQuery can be incredibly elegant, and we are frequently surprised at how very complex problems may be solved quite simply in XQuery when considered in a different light.
We should also perhaps mention that eXist is not just for XML documents. You can, in fact, store any file into the database, and eXist can do some very clever things with content extraction and metadata with non-XML documents to help you query and manage those binary formats too.
We could stop there and focus the rest of the book on the database, but you would really miss out on the good stuff. eXist is also a web server: you can make web requests directly to the database to store, retrieve, or update XML documents. eXist achieves this by providing an HTTP REST API that describes the database. It also provides a WebDAV interface so that your users can easily drag and drop documents from their desktops into the database, or open a document for editing.
But wait, there’s more! As eXist evolved over the years it became clear that being able to store, retrieve, and edit documents via the Web was neat, but also being able to store XQuery into the database and execute it via a web request from your web browser meant you could easily construct very powerful web applications directly on top of the database. eXist of course continued to evolve here, providing new features for forms, web application packaging, improved security, SQL queries, SSL, and support for producing and consuming JSON and HTML 5, among other offerings.
So, in summary, what is eXist?
A NoSQL document database for XML and binary (including text)
A web server for consuming and serving documents
A document search engine
A web application platform
A document creation and capture platform (XForms)
A data mashup and integration platform
An embeddable set of libraries for use in your own applications
Unlike traditional RDBMSs (Relational Database Management Systems) such as Oracle, MySQL, and SQL Server, which are table oriented, eXist is a NoSQL document-oriented database.
Many other NoSQL document databases (including MongoDB and Apache Cassandra) store JSON documents, whereas eXist stores XML documents. One of the key advantages of XML over JSON is the ability to handle complex document structures using mixed content. JSON easily handles data-oriented documents, while XML easily handles both data-oriented markup and text-oriented documents. Another key advantage of XML over JSON is that you can adopt namespaces to cleanly model different business domains.
RDBMSs and even several NoSQL databases require you to define your data schema before you can start storing your data. eXist is entirely flexible, and allows you to store your documents without specifying any schema whatsoever. It is ideal for business problems that have high-variability data and also helps developers rapidly prototype and evolve applications. However, schemaless should not be confused with providing validation of documents. Should you wish, you can also define a schema in eXist and have eXist enforce that only documents meeting your schema requirements are stored or updated.
RDBMSs typically use a standardized SQL query language; however, in practice, apart from the most basic queries it can be hard to run the same SQL queries across different RDBMS database products. Likewise, most NoSQL systems have their own proprietary query languages, which are entirely product-specific. eXist takes a very different approach and provides XQuery and XSLT, which are W3C standardized query and transformation languages, meaning that with very little effort you can execute your eXist queries on any other product that provides an XQuery and/or XSLT processor.
Like many database systems, eXist allows you to define different indexes for your searches. However, combined with the ability to search based on the document structure, this makes eXist search results more precise than those of almost any other database when dealing with structured documents such as TEI, DocBook, and DITA. eXist will consistently have better search metrics (precision and recall) than search systems that ignore document structure. If findability is high on your list of desired attributes, then eXist is a great choice.
Oracle provides Oracle forms for use with its RDBMS. We are not aware of any NoSQL databases that provide form support for constructing end-user interfaces that can feed directly into the database. eXist supports XForms (another W3C standard), which allows you to easily capture user input into XML documents in the database. Some organizations find that eXist is ideal not just for managing data collection with forms, but also for entire backend workflows around the content publishing process.
Like some RDBMSs and NoSQL databases, eXist is embeddable into your own applications. However, when you are using eXist as a server, it really becomes an application platform and offers more than almost any other database system. When running eXist as a server, you can develop entire applications in eXist’s high-level query languages (XQuery and XSLT) without necessarily having to be a computer scientist or programmer.
Most RDBMSs and many NoSQL databases allow you to control your transactions from within your database queries or API calls. Unfortunately, eXist does not currently support database-level transaction control. eXist does have transactions internally and uses a database journal to ensure the durability and consistency of your data, but these are not exposed to the user. Transaction control is high on the list of desirable features for eXist, and some options have already been explored for the future.
A feature of many RDBMSs and NoSQL database systems is the ability to cluster database nodes to increase database scalability and capacity. eXist is currently mostly deployed on single servers. As of this writing, it has no support for automatic sharding of data. eXist has recently gained support for replication in version 2.1 through JMS (Java Message Service) message queueing. The replication feature allows you to have a master/slave database, which is highly available for reads that may occur from any node, but it is still currently recommended to send writes to the master node. For further details of the emerging replication support in eXist, see https://github.com/eXist-db/messaging-replication/wiki.
Once upon a time, around the turn of the 21st century, there was a researcher named Wolfgang Meier working at the Technical University of Darmstadt. He was in need of a system to analyze and query XML data, and since there was nothing around that satisfied his needs, he decided to write something himself: eXist.
Starting out in C++, Meier quickly turned to Java, and by the beginning of 2001, a first version was available. It was based on a relational database backend and, compared to where we are now, very primitive. The functionality was basic and it was slow on indexing, but yes, it already had some XPath on board. Immediately, some dictionary research projects started using it.
The next stage was replacing the relational backend with native XML storage. While this was happening, more and more people started using eXist, and around 2004 the first commercial projects arrived. The development of eXist has since then mostly been financed by its users, who needed new functionality and were willing to pay for it.
Implementing XQuery met some resistance. At that stage, eXist was still mostly an XML database only. Why would you need something like XQuery if you already have XPath? Luckily (for us), a professor of literature really needed XQuery support and paid for its implementation. It was embedded in the product by 2005.
During 2005 eXist was going so well that Meier was able to quit his university job and concentrate on eXist projects only. By that time some other programmers had come on board, and they constitute what we now know as the original “core programmer team.” In alphabetical order, they were Pierrick Brihaye, Leif-Jöran Olsson, Adam Retter, and Dannes Wessels.
Up to 2006 the version number was kept to v0.xx, but in 2006 a real v1.0 was released!
By this time, having previously only communicated via the Internet, the core programmer team met live for the first time in 2007 in Versailles. One of the first things they did was to check eXist against the official XQuery test suite, which subsequently resulted in the current 99%+ compliance score.
The product kept evolving. A major improvement was replacing the existing scheme for node identifiers with a much better one. As a result of that, limitations on XML size and structure disappeared. Stability and transaction management were improved and the Lucene full-text search engine added. From the original research/retrieval tool, eXist evolved into something we really could call a native XML database.
The XRX (XForms, REST, XQuery) paradigm popped up as a way to create fully XML-driven applications. eXist was among the first engines that made this possible. It turned, slowly but surely, into a full-blown application platform.
With version 1.4 of eXist released in 2009, suddenly many more organizations were using eXist in their production systems day to day. More development effort went into stabilizing, fixing bugs, and improving reliability. With this, the first “settled application” problems arrived: it became harder and harder to change anything without breaking backward compatibility. Consider, for instance, eXist’s XQuery update support: an implementation of a draft version of the standard for writing XQuery statements to update XML. Switching to the final standardized version is virtually impossible because it would break backward compatibility and existing applications would stop working.
However, the development team did not stop working, and gradually the 2.0 version as we know it came to life. Release candidates were made available throughout 2012, containing a large number of major changes and additions to the previous versions:
Behind the scenes, the XQuery engine and optimizer were improved.
Support for (large parts of) XQuery 3.0 was added.
The way the indexes work was redesigned to reduce lock contention, offer modularity, and improve performance.
Security was reorganized and now works not only a lot faster, but also in a way most developers are comfortable with (i.e., similar to Unix-like systems).
The repository manager was added, opening the way to a more modular eXist.
RESTXQ, a standard for coupling function invocations to URLs, was added.
And, of course, numerous other small improvements were made.
The final version 2.0, released in February 2013, was a massive leap forward from 1.4, representing the culmination of more than three years’ worth of sustained development effort. As such, it was not completely without backward compatibility problems. For instance, existing XQuery applications will have to do something about their security settings before they can run on the new version. However, that’s not too hard and is well worthwhile.
Version 2.1 was released shortly after, in July 2013, and consisted mostly of bug fixes and a new version of eXide. In February 2014, a release candidate of eXist 2.2 was made available, which—along with the usual bug fixes—included a completely new range index based on Lucene that offered much improved query times.
Now, obviously we are passionate about eXist; otherwise, you would not be reading a book we have written on the subject. More importantly, though, we are passionate about open source, and even more so we are concerned with quality software and using the right tool for the job. Like any other product, eXist has both strengths and weaknesses, and it would be somewhat misleading if we were not to share the whole story with you. Pointing out the weaknesses of a software product for which you have bought a book may not help us sell more books, but we do hope it will help you make informed decisions.
As eXist has such a wide scope, it is impossible to compare it directly to other products; so, we compare it instead against other native XML databases that also couple web server and application platform capabilities.
eXist’s competitors can be split into two categories: those that are open source and freely available, and the closed source, commercial offerings. By no means is what follows a complete list, but it contains the offerings that we believe are popular and frequently encounter when talking to others.
A further independent comparison is available in the XML database article on Wikipedia.
Let’s begin with the open source eXist competitors.
BaseX is a lightweight native XML database with some application server facilities written in Java. The project was started in 2005 by Christian Grün at the University of Konstanz, and BaseX was released as open source in 2007. BaseX promotes ease of use and provides an easy-to-use GUI frontend also written in Java.
Compared to eXist, BaseX adheres more closely to the W3C XQuery specifications, achieving 99.9% compliance with the W3C XQuery 1.0 specification (eXist has 99.4%) and implementing the specifications for XQuery Update 1.0 and XQuery Full-Text. eXist has an older draft implementation of XQuery Update and its own proprietary full-text search. eXist, however, has been available for significantly longer, and thus benefits from many more features, such as XSLT.
BaseX is released under the more liberal BSD license. Commercial support is available for BaseX from BaseX GmbH, which was founded to support commercial applications of BaseX.
Sedna is a lightweight native XML database without application server capability, written in C and C++. The origins of Sedna are not well documented, but it appears to have started around 2003 as a project of the Institute for System Programming at the Russian Academy of Sciences. Sedna seems to focus on providing core database services and little more. While it has no REST Server of its own, it can be configured to work as a module within the Apache HTTP Server.
Compared to eXist, Sedna supports more APIs for different programming languages directly; eXist mostly assumes that developers will use its REST or RPC APIs, and leaves language APIs to third-party providers. Sedna reports 98.8% compliance with the W3C XQuery 1.0 specification; as mentioned previously, eXist has 99.4% compliance. Sedna, like eXist, implements its own proprietary full-text search, and a draft version of XQuery Update.
Sedna is released under the Apache 2.0 license. There does not appear to be a commercial support offering for Sedna.
Now we’ll take a look at eXist competitors that are closed source and commercially available.
28.io is a PaaS (Platform as a Service) for the Zorba open source XQuery processor. 28.io integrates Zorba with MongoDB, supporting the storage and indexing of XML into MongoDB as its main datastore. The query optimizer leverages the full capabilities of MQL (Mongo Query Language), enabling developers to leverage the expressiveness and productivity of XQuery atop a highly scalable store.
In comparison with eXist, 28.io focuses on the cloud and manages its database entirely using XQuery, whereas eXist provides a number of Admin GUI tools and additional APIs. 28.io, much like eXist, provides an application server platform enabling you to build entire apps using XQuery. 28.io (through Zorba) has similar compliance to the W3C XQuery 1.0 specification as eXist, but also supports XQuery Update, XQuery Full-Text, and XQuery Scripting. 28.io’s main advantage over eXist is its cloud scaling; eXist’s main advantage is XSLT, XRX, and XForms support.
28.io is developed by 28msec. 28msec is based in Zurich, Switzerland, and has strong research links with ETH Zürich.
MarkLogic Server is a standalone native XML database server, written in C++, that provides XQuery and XSLT query and transform capabilities. MarkLogic Server also has the capability to cluster nodes to scale horizontally, with the additional capability to pass large batch processing jobs off to Hadoop. MarkLogic distances itself from the technical marketing of XML and XQuery and instead identifies itself as a NoSQL database solution for the enterprise.
Compared to eXist, MarkLogic markets itself as being able to handle petabytes of XML data. eXist can currently scale to hundreds of gigabytes, but this is very much dependent on the dataset and queries made. MarkLogic lacks a document-representative REST API, but does provide a REST API for application development. MarkLogic’s main advantage over eXist is scaling to huge datasets, while eXist’s advantage is its fast innovation and rich feature set. Both support XSLT, but MarkLogic does not support XQuery Update; rather, it provides its own proprietary functions.
How many people are using it
Who the people using it are
What it is being used for
From the support channels available to eXist users, and as a member of the community, you can see that eXist is used by many people for many different purposes, but their end goals and projects are not always disclosed or clear.
Here we have pulled together a few descriptions of various projects using eXist from the developers of those projects themselves:
The Tibetan Buddhist Resource Center (TBRC) holds the world’s single largest collection of Tibetan texts—nearly 10 million scanned pages and over 11,000 Unicode Tibetan texts. TBRC.org provides online access to over 4,000 users via an Ajax client written in Google Web Toolkit as a front-end to the eXist-db. TBRC has used eXist-db since 2004 to store the catalog for the texts in the library as well as a knowledge-base of persons and places that provide a cultural context for Tibetan literature. The integration of eXist-db with the Lucene full-text indexing has created a powerful framework with which TBRC.org is able to provide searchable access to the library via comprehensive tables of contents in Tibetan and a large collection of texts that have been input in Unicode in centers around the world. Our production system currently runs eXist-db 2.1.
Senior Technical Staff Member,
Tibetan Buddhist Resource Center,
ScoutDragon initially started as a baseball research project by a group of baseball enthusiasts including writers, agents, scouts, fans, fantasy owners, and even former players. This group realized a need for original English content, data, and research on baseball players in Asia.
All data for multiple sports covering multiple sporting leagues is stored in XML documents within eXist in a schema derived from IPTC’s SportsML, most extensions having to do with providing multi-lingual support of players so that information may be displayed in English, Japanese, Korean, and/or Chinese. XQuery has proven to be a fantastic language for not just transforming the vast quantities of data to web pages, but also for data analysis and the generation of sabermetrics-based statistics.
Lead Programmer/System Administrator,
Semanta’s core business is metadata in business intelligence. Part of our concern is parsing metadata from reporting platforms. Many of these reporting platforms supply their metadata in large XML chunks, which we then need to further process efficiently. A typical example is our IBM Cognos connector, where we use eXist heavily to extract details of report structures and data sources. Originally we thought we would only use eXist for prototyping, but ultimately, we have used embedded eXist in the production system; re-writing the connector without eXist’s XQuery turned out to be just too complicated!
The Centre for Document Studies and Scholarly Editing of the Royal Academy of Dutch Language and Literature (Ghent, Belgium) develops rich scholarly collections of textual data, and publishes them as digital text editions and language corpora. From the start, we have fully embraced open standards and publication technologies. At first, we started out with the Cocoon XML publication framework, which back then nicely integrated with eXist (or the other way round) for efficient querying of XML content. Since the introduction of eXist’s MVC framework, we have extended our use of eXist as a full application server, not only for querying the indexed data, but also driving the entire application and presentation logic.
The texts we’re querying (or rather, processing) with eXist are mostly document-centered XML documents that are conformant to the schemas developed by the Text Encoding Initiative (TEI). Depending on the specific edition project, they are enriched with metadata such as named entities, editorial annotations, and sometimes highly specific textual documentation (such as critical apparatuses documenting variation among text versions). Though our texts are mostly in Dutch, we try to connect and contribute to methodological good practice emerging in the interesting field that is Digital Humanities. Some of our exemplar projects include a collection of letters in relation to the Belgian literary journal Van Nu en Straks; a digital edition comparing 20 versions of De trein der traagheid, a novel by the Belgian novelist Johan Daisne; and a digital edition of the first Dutch dialect survey in the Flemish region by Pieter Willems (developed between 1885–1890).
Ron Van den Branden,
Centre for Scholarly Editing and Document Studies of the Royal Academy of Dutch Language and Literature,
At the Cluster of Excellence “Asia and Europe in a Global Context,” we use eXist-db to store our collections of MODS (bibliographical) and VRA (image metadata) records. We have developed two open source applications for this, Tamboti and Ziziphus, where our records can be searched and edited. Both applications are built entirely in XML technologies (XQuery and XForms) using eXist-db and make use of LDAP integration and detailed user rights management.
Heidelberg Research Architecture,
Cluster of Excellence “Asia and Europe in a Global Context,”
The University of Heidelberg,
Haptix Games is a video game and interactive application development and publishing studio, and we have been a Microsoft shop for as long as I can remember. We have leveraged C#, MVC, and IIS for user experience; WCF, OData, and BizTalk for message exchanges; MSSQL and Entity Framework for storage. That is a lot of acronyms and even more complexity under the hood. Prototyping a concept usually involved all above-mentioned technologies, while the final solution release was either expensive, inflexible, or did not meet client expectations.
With the adoption of eXist-db our development and release workflows have become highly agile and more competitive. Utilizing eXist-db as a dark-data solution platform and not just another XML database allowed us to eliminate 80% of our Microsoft code base just by taking advantage of the built-in web server, low-level data manipulation using XQuery 3.0, restful data exchange, and native storage capabilities.
easyDITA is an end-to-end solution for collaboratively authoring, managing, and publishing content using the DITA XML standard. Companies utilize easyDITA to reduce the cost and time to market to deliver content in a variety of formats and languages. By leveraging eXist, easyDITA is able to deliver customers exceptional ability to search, manage, localize, and publish content. eXist’s schemaless design and flexible indexing system makes it easy to support customizations like reporting, analytics, and new content models without sacrificing performance or doing major redesigns.
easyDITA, Jorsek LLC,
Rochester, New York
We [at XML Team Solutions] help media and entertainment companies integrate sports news and data feeds. These feeds are predominantly XML. We use eXist for two things:
Regulating and preparing vendor web service XML for transmission to clients. Scheduled jobs access remote web services, preprocess, and pass on XML via HTTP Client to our main feed processor.
API to drive graphics for live television broadcast. API built from RESTXQ provides live updates of results to broadcaster clients. Currently uses JMS to sync from one write DB to two load-balanced readers. Also has an XForms “beat the feed” live score updater which mimics the incoming feed in case feed vendor is delayed.
We recently delivered a project for BBC Sports to deliver live broadcast information. eXist met all the requirements for speed, cost, and reliability for an API to deliver up-to-date scores and statistics to BBC television.
Director of Software Development,
XML Team Solutions Corp,
eXist-db is at the core of [the Office of the Historian’s] open government and digital history initiatives. It powers our public website, allowing visitors to search and browse instantly through nearly a hundred thousand archival government documents. On the fly, it transforms our XML documents and query results into web pages, PDFs, ebooks, and APIs and data feeds. Its support of the high-level XQuery programming language and its elegant suite of development tools empower me and my fellow historians to analyze data and answer research questions.
The open source nature of eXist-db has delivered far more value to us than its simply being “free”; its active, welcoming, expert collaborative user community has helped us learn, discover eXist-db’s plethora of capabilities, and find the best solutions to our research and publishing challenges. eXist-db belongs in the toolkit of all digital humanities, open government, and publishing projects.
Office of the Historian,
U.S. Department of State
There is a vibrant and supportive community around the eXist software, whose goal it is to make using eXist easy for beginners and as painless as possible for advanced developers. The eXist community prides itself on the agility and quality of its responses to support requests.
There are many ways to contribute to eXist and the community. You need not be a crack software engineer; even beginners asking questions on the mailing list can help others learn from their issues and encourage the developers to simplify or consider new approaches.
To get in touch with the eXist community, you have several channels available to you:
This is the official preferred mechanism, and your best bet for getting a quick answer. There are also the eXist-development and eXist-commits mailing lists; the former is used for technical discussion of features and fixes that go into eXist, and the latter is a feed of any changes made to the source code of eXist.
For further details, see http://sourceforge.net/p/exist/mailman/, http://exist-open.markmail.org, and http://www.exist-db.org/exist/apps/doc/getting-help.xml.
While the mailing lists should currently be considered the primary support mechanism, Stack Overflow is also becoming popular for asking eXist questions. You can find eXist questions and answers under the exist-db tag.
The Twitter channel is monitored by the core developers of eXist. It’s mostly used for announcements about eXist, as providing tech support in 140 characters is tough!
The eXist IRC chat room (irc://irc.freenode.net/existdb) is for the community, by the community. It can be a mix of users and developers and is often worth a visit, but getting a response can really depend on who is awake and logged in.
As a user of eXist, be sure to do the following:
There are no stupid questions. Importantly, all questions and answers on the mailing list are archived so that others may learn from them also. Sensibly, you should search the archive first, to see if your question has already been answered; if not, or if the answer’s not clear, then ask away!
All software has bugs! eXist is no exception. If you think you have found a bug, it is probably best to discuss it on the eXist-open mailing list first, and then, if it’s confirmed, log it in the eXist issue tracker on GitHub.
If you want to report a bug, it’s very important that the developers of eXist understand how to reproduce what you are seeing; if you can’t describe the problem and its cause, it’s very hard for the community to help you! Ideally you should provide a reproducible test case of the absolute minimum steps required to cause the issue. See “Getting Support” for more detail.
As you begin to use eXist, you will start to learn more and more things that other users may not know. Why not get some good karma back by answering some questions on the mailing list? After all, it’s a community!
If you’re having a great time using eXist, or you are enthralled by some neat feature, tell your friends, and let us and everyone else know by writing a blog entry or article.
Open source developers are often working on a project for “the love of it,” and many of the developers of eXist contribute much of their time to the project completely unpaid. Sadly, love for developing open source code with your friends does not necessarily equate to food or shelter. If you’re part of an organization making free use of eXist, there are a number of ways that you can contribute back to the community:
Perhaps there is some feature that you wish that eXist had that would really help your project, or there is a bug that sometimes upsets your system. Your organization could financially sponsor a developer from the eXist community to add this feature or resolve that issue. Sponsoring eXist developers for small or large projects helps support them in their work on eXist and could provide new or improved functionality to the community. If you want to give something back financially but have no specific features or bug fixes in mind, just get in touch via eXist-open and the community will helpfully propose a project to meet your budget.
If you have developers in your organization, empowering them to spend a small amount of their paid work time contributing to the development of eXist can also be a great way to give back to the community. For example, Google allows its developers to work on open source projects on Friday afternoons and has realized various benefits from this.
Are you looking for someone who is an expert in eXist and XQuery and/or XML technologies? The eXist-open mailing list can be a great place to advertise. You will more than likely end up sponsoring one of the contributors to eXist, as they tend to be the people who really know it inside and out.
If you’re serious about using eXist in your projects and running production systems on it, you will more than likely want the support and operational security afforded by purchasing a support contract for it. eXist Solutions provides a variety of support contracts and consultancy services for eXist. It was founded by core developers of eXist and contributes almost all of its resources back into developing the software. By working with eXist Solutions, you are closely supporting and funding eXist’s development.
If you’re an author using eXist, here’s how you can contribute:
eXist has a large set of documentation that accompanies it, but it is by no means complete or exhaustive. You do not have to be a developer to write documentation for eXist, and all improvements to the documentation are warmly accepted.
Developers using eXist can give back in the following ways:
Found a bug? Want to submit a patch or new feature? Why not roll up your sleeves and get your hands dirty? In the beginning the eXist code base may seem intimidating in its size, but it’s fairly modular and easy to get around. And if you have the skills, there is often no quicker way to get something fixed than to do it yourself, while hopefully learning a few new and interesting things along the way. Bug reports should be posted to the eXist-development mailing list first, and then logged in the issue tracker on GitHub. Patches can be submitted by means of a pull request to the eXist GitHub repository.
For further information about developing eXist, see “Developing eXist”.
This section contains additional informational resources. It’s compiled from our personal preferences and bookshelves, meaning there are many other good sources of information around. However, this list is a good place to start:
XQuery, by Priscilla Walmsley (O’Reilly, 2007)
This is probably the best XQuery book available in our opinion.
XQuery wikibook, edited by Dan McCreary et al.
The XQuery wikibook is an excellent resource for XQuery and eXist ,with the majority of the examples developed for eXist.
XRX wikibook, edited by Dan McCreary et al.
The XRX wikibook, like the XQuery wikibook, is an excellent resource when you’re building applications atop eXist using REST and XForms.
The F+O specification is a great resource for quickly looking up the available functions and their specification for XQuery, XPath, and even XSLT.
XQuery: The XML Query Language, by Michael Brundage (Addison-Wesley, 2004)
This was a great book at the time it was published; while still relevant, it was released before the final XQuery 1.0 specification.
XQuery from the Experts: A Guide to the W3C XML Query Language, by Don Chamberlin et al. (Addison-Wesley, 2004)
Again, this book was released before the final XQuery 1.0 specification, but it is useful for those who want to know the nitty-gritty details like the formal underpinnings of the language.
The xquery-talk mailing list is a great place to ask XQuery questions that are not specific to eXist-db.
XSLT 2.0 and XPath 2.0: Programmer’s Reference, 4th Edition, by Michael Kay (Wiley, 2008)
The XSL-List is the best place to ask XSL questions and receive help. Note that it has an excellent archive; we suggest that you search that first for an answer before asking!
XSLT Questions and Answers—FAQ, curated by Dave Pawson
The XSLT FAQ is an incredible resource that has many answers from those who were involved in specifying XSLT and those recognized as subject experts.
XSLT, 2nd Edition, by Doug Tidwell (O’Reilly, 2008)
XSLT Cookbook, 2nd Edition, by Sal Mangano (O’Reilly, 2006).
Also a very handy book to have when you only sporadically program XSLT; it contains many useful “recipes.”
XForms Tutorial and Cookbook wikibook, edited by Dan McCreary
The XForms wikibook is an excellent resource for XForms examples, especially as many of the articles are developed against eXist.
XForms Essentials, by Micah Dubinko (O’Reilly, 2003)
An excellent reference guide to have when you’re working with XForms, with some good explanations of the W3C XForms specification.