构建系统未以文件为中心 [英] Build system that is not file-centric

问题描述

我们有一个软件基础设施，很多作品pretty像软件构建系统：信息从不同来源收集并用来产生一些输出。像传统的软件构建我们有不同类型的输出，依赖树木等。

We have a software infrastructure which works pretty much like a software build system: Information is gathered from different sources and used to generate some outputs. Like in traditional software builds we have different types of output, dependency trees, etc.

的主要区别在于我们的源，中间结果和输出不是固有的基于文件的。相反，他们是（唯一寻址）的数据对象。

The main difference is that our sources, intermediate results and outputs are not inherently file-based. Rather, they're (uniquely addressable) data objects.

现在，我们正在映射我们的数据结构，文件和目录，结合传统的构建系统（SCons的），但没有规模，既w.r.t.性能，而且（更重要的）w.r.t.可维护性。因此，我在寻找一个专门针对从地上爬起来这个目的建造的基础设施。

Right now we're mapping our data structure to files and directories in combination with a traditional build system (SCons) but that does not scale, both w.r.t. performance but (more importantly) w.r.t. maintainability. Hence I'm looking for an infrastructure that's built for this purpose from the ground up.

作为一个例子，假设你有3个XML文档 A ， B 和Ç 。比方说， B /富/条是从 A / X / Y 和 A / X / Z ，这同样 C / A / b 是 A / X / Y 。我需要一个基础设施，以

As an illustration, assume you have 3 XML documents A, B and C. Let's say that B/foo/bar is to be calculated from A/x/y and A/x/z, and that similarly C/a/b is calculated from A/x/y. I need an infrastructure to

1. 实施这些关系（即变换和它们的依赖）


2. 自动重新建立的相关部分更改后，

使用文件的一个主要问题是，如果我映射 A ， B 和 C 来的一些文件 A.xml ， B.xml 和 C.xml 并使用传统的编译系统，然后的任何的更改 A.xml 将触发重建 B.xml 和 C.xml ，即使 A / X / Y <中/ code>和 A / X / Z （ B 原来依赖）不会被修改。对于细粒度的依赖解析，因此我需要映射每个 A ， B 和 C 不是一个文件，而是每个子目录再presents元素的目录，文件重新presents属性等。正如我所说的，这并不规模求我们的。

One major problem with using files is that, if I map A, B and C to some files A.xml, B.xml and C.xml and use a traditional build system, then any change to A.xml will trigger a rebuild of B.xml and C.xml, even if A/x/y and A/x/z (the original dependencies of B) are not modified. For a fine-grained dependency resolution I therefore would need to map each of A, B and C not to a file, but to a directory where each sub-directory represents an element, files represents attributes, etc. As I said, this does not scale for us.

（请注意，我们的系统实际上不基于XML）

(Please note that our system is not actually based on XML)

现在我正在寻找任何现有的软件，基础设施或概念指向这个方向，无论实现语言和底层数据结构。

Right now I'm looking for any existing software, infrastructure or concept which points into this direction, regardless of implementation language and underlying data structures.

推荐答案

这听起来像你需要一个活动对象数据库管理系统（的 ODBMS ）如 GemStone的/ S 。 ODBMSs提供传统的持久性服务，而无需映射的数据结构的文件的旧成本和对象技术的公知的好处。如你提到的依赖性树和寻址的目的，在ODBMSs导航引用存储作为它们的数据的一部分，从而使对象之间的任何复杂的交互模式被重新presented /访问。这是专真实，当你predict一个系统，利用继承，对象嵌套和交叉引用的。

It sounds like you need an active object database management system (ODBMS) like GemStone/S. ODBMSs provide the traditional persistence services without the old cost of mapping data structures to files and the well-known benefits of object technology. As you've mentioned dependency trees and addressable objects, in ODBMSs navigational references are stored as part of their data, allowing any complex interaction patterns among objects to be represented/accessed. This is specially true when you predict a system which makes use of inheritance, object nesting and cross-referencing.

虽然对象引擎可能看起来超大您的要求，是很常见的大规模生产的业务系统来存储和使用OODBMS执行方法中，同时和多用户环境内。它不是免费的，因为你必须投资于方程（教育和经验）的人类本性的一部分，但一旦最初的恐惧被克服，该公司将支付的投资回报率。

Although an object engine may seem oversized for your requirements, it is common for large-scale production business systems to store and execute methods using OODBMs, within a concurrent and multiuser environment. It doesn't come for free because you have to invest in the human part of the equation (education and experience) but once the initial fear is overcome, it will pay the return of investment.

有关重楼（认购）部分的变化（从播音员通知）制成后，您可以使用 Observer设计模式，或其变体之一（ SASE 或<一个href=\"http://www.cincomsmalltalk.com/userblogs/vbykov/blogView?showComments=true&entry=3310034894\"相对=nofollow>公告框架），来实现你的公布/订阅架构。在这种类型的事件框架有哪些是很难与传统的基于文件的解决方案来解决，因为你已经注意到了内在的问题。例如，它是一个典型的依赖机制来管理替换的对象，或在例如XML文档，由另一个。任何现代的事件框架应该管理当一个对象被删除，插入到老对象的所有家属更新为新的参考。

For re-building (subscribed) parts after changes (notifications from announcers) are made, you may use the Observer design pattern, or one of its variants (SASE or Announcements framework), to implement your announce/subscription architecture. Under this type of event frameworks there are intrinsic problems which are hard to solve with traditional file-based solutions, as you have noticed already. For example, it is typical for a dependency mechanism to manage the replacement of an object, or in your example an XML document, by another one. Any modern events framework should manage when an object is removed, all dependents plugged to the old object are updated to the new reference.

最后，有一个免费的 GemStone的/ S堆栈其中包括对象的依赖框架，这样你可能实验与真正的对象数据库。

Finally, there is a free GemStone/S stack which includes object dependency framework so you may experiment with a real object-database.

这篇关于构建系统未以文件为中心的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！