Yes and no. Integration effort is probably still 3x, but now it's amortized over the whole development process (e.g. early integration, integration tests (esp. in TDD), etc.)
We still have to do the work but it doesn't catch us by surprise anymore.
That was referring to the bad old days when they built all the software components separately and then tried to put them all together. Smart people don't work like that anymore - they integrate continuously.
I would agree, if not higher. Though it really depends on the integration touch points.
I was involved on a project to carry out integration of a number of modules between Siebel and SAP. While both of these products have integration modules available, all the problems on the project (and there were many) were involved in the integration.
It wasn't helped by the fact that the majority of SAP that we were using was in German, and the messages being transfered were in different XML encoding formats (UTF8 / UTF16).
Once we'd got to grips with the intricacies of what SAP wanted to send and recieve, the whole project moved along much quicker.
Key things for a successfull integration project:
Good documentation (in English!) on the integration modules
Good documentation on the message formats
Good project management
The project management bit is important as they supply the pizza, and do show some understanding when you have been working 30 hours straight to get an account name from one textbox on one machine to appear in another textbox on another machine.
Our project lasted over a year. The rest of the configuration of Siebel that we did, which was alot was only a couple of months,
So Integration - 10 months+, rest of the config 2 months.
CI 绝对比其他方案更好。 等到开发周期后期才进行集成势必会给您带来很大的痛苦。 越早开始集成，每个团队就越能适应这个过程。
Integration time depends on a few of factors: the size of the project, communication between teams, and your integration philosophy.
Small projects take less time to integrate. Large, very large, or huge projects will take more time to integrate. I've been on small projects where integration was minimal. I've been on huge projects spread across multiple component teams where integration took a very long time.
Time to integrate also depends on how well you project communication across teams. If your teams are not communicating it can take 3x or more time to integrate and work out all the related bugs.
Continuous integration helps with the perception that integration takes less time. With CI the time to integrate is amortized over the life of the project. But again if you have a poor relationship with the other component teams to total time for all integrations will take non-zero time.
CI is definitely better than the alternative. Waiting until late in the development cycle to integrate is bound to cause you much pain. The earlier you begin the integration the more comfortable each team becomes with the process.
Kind of a side note, there is an interesting talk given by Juval Lowey regarding this. If you have many tiny components, then you increase effort to integrate. If you have only a few large components, you decrease integration, but you have more complex components to maintain. So your effort to integrate is dependent on the architecture and where it balances the number of components to their complexity. A good balance is key, because if you drift too one side or the other, the effort required increases exponentially. If you have 20 components and add a 21st, it's not just 5% (1/20) more complex, because you have to consider the interactions of the potentially other 20 components. So adding one component adds the potential for 20 ways to interact with the existing components. Of course a good design will limit this interaction to as few components as possible, but that was basically why Juval felt it was exponential.
马库斯非常正确，这可以在项目的整个生命周期内摊销集成成本。 对我们来说，这使得成本比我们将成本更多地推迟到周期结束时要低得多。 这就是过去的运作方式。 不是为了晾晒太多脏衣服，但是当我大约 5 1/2 年前开始使用 Windows 时，构建一个版本花了非常非常长的时间。 现在它们每天都在发生，就像钟表一样。 Windows 工程工具和发布组 (WETR) 获得了这一切的功劳。
正如许多其他人在各种论坛中建议的那样 - 定期集成和每日完全自动化构建对于大多数项目至关重要。
请注意，日常和定期的自动化测试是一个完全不同的主题（正如您可以想象的那样，这是一项巨大的工作）。
Neil and Markus' answers are spot on. In Windows, we integrate continuously. Our source code control system (we call it "Source Depot") is hierarchical with "WinMAIN" being at the top, and a tree of branches underneath it that general correspond to the organizational structure.
In general, changes flow up and down this tree in a process of "forward integrations" and "reverse integrations". This happens very regularly - almost every day for the top level branches under winmain, and a bit less often for the lower level branches. Each major branch builds fully every day in at least four flavors. The top level branches build in six flavors. A flavor is something like x86/fre, or x64/chk. We also get some daily pseudo localized builds as well.
By "build" I mean build a fully installable Windows client product from source. This happens several hundred times per day.
This works well for us - there are two important goals here:
maintaining good code flow (we call it velocity) up and down the tree. The idea is that any branch is never too different from WinMAIN.
Catching integration errors as early as possible.
Markus is very correct that this amortizes integration costs over the life of the project. For us, this makes the costs a LOT lower than they would be if we deferred costs more toward the ends of cycles. This is how things used to work. Not to air too much dirty laundry, but when I started in Windows about 5 1/2 years ago, getting a build out took a very, very long time. They now happen every day, like clock work. The Windows Engineering Tools and Release group (WETR) gets all the credit for this.
As many others have suggested in various forums - regular integration and full daily automated builds are essential for most projects.
Note, daily and regular automated test are a whole other topic (its a massive effort as you can imagine).
发布评论
评论（7）
是和不是。 集成工作可能仍然是3倍，但现在它在整个开发过程中摊销（例如早期集成、集成测试（尤其是TDD）等）
我们仍然需要做这些工作，但它并不不要再让我们感到惊讶了。
Yes and no. Integration effort is probably still 3x, but now it's amortized over the whole development process (e.g. early integration, integration tests (esp. in TDD), etc.)
We still have to do the work but it doesn't catch us by surprise anymore.
这指的是过去的糟糕日子，当时他们单独构建所有软件组件，然后试图将它们全部组合在一起。 聪明人不再那样工作——他们持续集成。
That was referring to the bad old days when they built all the software components separately and then tried to put them all together. Smart people don't work like that anymore - they integrate continuously.
我会同意，如果不是更高的话。 尽管这实际上取决于集成接触点。
我参与了一个在 Siebel 和 SAP 之间集成多个模块的项目。 虽然这两种产品都有可用的集成模块，但项目中的所有问题（而且有很多）都涉及集成。
我们使用的大多数 SAP 都是德语，并且传输的消息采用不同的 XML 编码格式（UTF8 / UTF16），这对我们没有帮助。
一旦我们掌握了 SAP 想要发送和接收的复杂信息，整个项目就会进展得更快。
成功集成项目的关键要素：
项目管理位很重要，因为他们提供披萨，并且在您工作时确实表现出一些理解连续 30 小时从一台计算机上的一个文本框中获取帐户名称，以显示在另一台计算机上的另一个文本框中。
我们的项目持续了一年多。 我们所做的 Siebel 的其余配置仅花费了几个月的时间，
因此集成 - 10 个月以上，其余的配置需要 2 个月。
I would agree, if not higher. Though it really depends on the integration touch points.
I was involved on a project to carry out integration of a number of modules between Siebel and SAP. While both of these products have integration modules available, all the problems on the project (and there were many) were involved in the integration.
It wasn't helped by the fact that the majority of SAP that we were using was in German, and the messages being transfered were in different XML encoding formats (UTF8 / UTF16).
Once we'd got to grips with the intricacies of what SAP wanted to send and recieve, the whole project moved along much quicker.
Key things for a successfull integration project:
The project management bit is important as they supply the pizza, and do show some understanding when you have been working 30 hours straight to get an account name from one textbox on one machine to appear in another textbox on another machine.
Our project lasted over a year. The rest of the configuration of Siebel that we did, which was alot was only a couple of months,
So Integration - 10 months+, rest of the config 2 months.
集成时间取决于几个因素：项目的规模、团队之间的沟通以及您的集成理念。
小项目需要更少的时间来集成。 大型、超大型或巨型项目将需要更多时间来集成。 我参与过集成程度最低的小型项目。 我参与过跨多个组件团队的大型项目，其中集成需要很长时间。
集成时间还取决于您跨团队沟通的效果。 如果您的团队不进行沟通，则可能需要 3 倍或更多的时间来集成和解决所有相关错误。
持续集成有助于增强集成所需时间更少的感觉。 对于 CI，集成时间会在项目的整个生命周期内摊销。 但同样，如果您与其他组件团队的关系不好，则所有集成的总时间将花费非零时间。
CI 绝对比其他方案更好。 等到开发周期后期才进行集成势必会给您带来很大的痛苦。 越早开始集成，每个团队就越能适应这个过程。
Integration time depends on a few of factors: the size of the project, communication between teams, and your integration philosophy.
Small projects take less time to integrate. Large, very large, or huge projects will take more time to integrate. I've been on small projects where integration was minimal. I've been on huge projects spread across multiple component teams where integration took a very long time.
Time to integrate also depends on how well you project communication across teams. If your teams are not communicating it can take 3x or more time to integrate and work out all the related bugs.
Continuous integration helps with the perception that integration takes less time. With CI the time to integrate is amortized over the life of the project. But again if you have a poor relationship with the other component teams to total time for all integrations will take non-zero time.
CI is definitely better than the alternative. Waiting until late in the development cycle to integrate is bound to cause you much pain. The earlier you begin the integration the more comfortable each team becomes with the process.
顺便说一句，Juval Lowey 对此做了一次有趣的演讲。 如果您有许多微小的组件，那么您就会增加集成的工作量。 如果您只有几个大型组件，则会降低集成度，但需要维护更复杂的组件。 因此，您的集成工作取决于架构以及它在组件数量与其复杂性之间的平衡。 良好的平衡是关键，因为如果你向一侧或另一侧偏离太多，所需的努力就会成倍增加。 如果您有 20 个组件并添加第 21 个组件，那么复杂程度不仅仅增加了 5% (1/20)，因为您必须考虑其他 20 个组件之间潜在的相互作用。 因此，添加一个组件就可以增加 20 种与现有组件交互的方式。 当然，好的设计会将这种交互限制在尽可能少的组件中，但这就是 Juval 认为它呈指数级增长的根本原因。
Kind of a side note, there is an interesting talk given by Juval Lowey regarding this. If you have many tiny components, then you increase effort to integrate. If you have only a few large components, you decrease integration, but you have more complex components to maintain. So your effort to integrate is dependent on the architecture and where it balances the number of components to their complexity. A good balance is key, because if you drift too one side or the other, the effort required increases exponentially. If you have 20 components and add a 21st, it's not just 5% (1/20) more complex, because you have to consider the interactions of the potentially other 20 components. So adding one component adds the potential for 20 ways to interact with the existing components. Of course a good design will limit this interaction to as few components as possible, but that was basically why Juval felt it was exponential.
尼尔和马库斯的答案很正确。 在Windows 中，我们不断地集成。 我们的源代码控制系统（我们称之为“Source Depot”）是分层的，“WinMAIN”位于顶部，其下的分支树通常与组织结构相对应。
一般来说，变化在“正向集成”和“反向集成”的过程中沿着这棵树上下流动。 这种情况发生得非常频繁——对于 winmain 下的顶级分支来说几乎每天都会发生，而对于较低级别的分支来说则不太频繁。 每个主要分支每天都至少以四种风格构建。 顶级分支有六种风格。 风格类似于 x86/fre 或 x64/chk。 我们还获得了一些日常伪本地化版本。
我所说的“构建”是指从源代码构建一个完全可安装的 Windows 客户端产品。 这种情况每天会发生数百次。
这对我们来说效果很好——这里有两个重要的目标：
马库斯非常正确，这可以在项目的整个生命周期内摊销集成成本。 对我们来说，这使得成本比我们将成本更多地推迟到周期结束时要低得多。 这就是过去的运作方式。 不是为了晾晒太多脏衣服，但是当我大约 5 1/2 年前开始使用 Windows 时，构建一个版本花了非常非常长的时间。 现在它们每天都在发生，就像钟表一样。 Windows 工程工具和发布组 (WETR) 获得了这一切的功劳。
正如许多其他人在各种论坛中建议的那样 - 定期集成和每日完全自动化构建对于大多数项目至关重要。
请注意，日常和定期的自动化测试是一个完全不同的主题（正如您可以想象的那样，这是一项巨大的工作）。
Neil and Markus' answers are spot on. In Windows, we integrate continuously. Our source code control system (we call it "Source Depot") is hierarchical with "WinMAIN" being at the top, and a tree of branches underneath it that general correspond to the organizational structure.
In general, changes flow up and down this tree in a process of "forward integrations" and "reverse integrations". This happens very regularly - almost every day for the top level branches under winmain, and a bit less often for the lower level branches. Each major branch builds fully every day in at least four flavors. The top level branches build in six flavors. A flavor is something like x86/fre, or x64/chk. We also get some daily pseudo localized builds as well.
By "build" I mean build a fully installable Windows client product from source. This happens several hundred times per day.
This works well for us - there are two important goals here:
Markus is very correct that this amortizes integration costs over the life of the project. For us, this makes the costs a LOT lower than they would be if we deferred costs more toward the ends of cycles. This is how things used to work. Not to air too much dirty laundry, but when I started in Windows about 5 1/2 years ago, getting a build out took a very, very long time. They now happen every day, like clock work. The Windows Engineering Tools and Release group (WETR) gets all the credit for this.
As many others have suggested in various forums - regular integration and full daily automated builds are essential for most projects.
Note, daily and regular automated test are a whole other topic (its a massive effort as you can imagine).
如果您的项目计划在项目接近尾声时有一个集成阶段，那么您就注定失败，而 x3 也不算太糟糕。
您应该选择持续集成，例如每两周发布一个版本，在此之前进行一些集成。
If you have an integration phase towards the end of your project on you project plan you are doomed and x3 is not too bad.
You should rather go for continuous integration, where you have, say every 2 weeks, a release with some integration before it.