Making multiple teams coexist
-
Hi, I'll make it short and clear (I hope). We have two teams developping our product, the R&D and the 'Integrators'. I'm not sure how the Integrators are called in english, maybe TPAM (Third Party Application Maintenance), anyway, let's say that Integrators = People working on the base product, adding or changing functionalities for a specific customer. And the R&D team beeing in charge of doing what's common to all of them (the customers). The R&D team is in charge of developping functionalities available to all our customers, and the other team only does specific developments for specific customers. The problem we're dealing with is that both teams may develop on the same web pages, controls, business logic etc. What happens is that our Release Manager deploys what the R&D team has been doing in some sort of common workspace, and he can't be aware of what's from one team or another, so a lot of times, the Integrators work is lost and our release manager spends hours finding the 'lost changesets' and re applying those modifications. We're need to solve this problem and what we came with far now is to develop some sort of API exposing all the common asp.net events (page_init, load, render, etc.), we also should fire events when entering/exiting BL and DAL functions allowing the Integrators to develop 'manually', maybe injecting some asp.net code into the existing pages, also some code behind, javascript, etc. I'm not really sure if this is a reasonable idea or not, we've just been thinking for like 10 minutes and I wondered what did you recon in this kind of situations. This is just an idea, because they may develop everywhere... Web, BL, DAL and Database (we have a project for that). Just to be clear, we're developing a product, I'm not sure how it's technically called in English but our application will keep growing over time so we really need to do this right otherwise it will cost us a lot of time and money to correct that later when we'll have people using our 'API' (I'm calling this an API but I may be wrong about that) Anyway, we're stuck here, I hope I was clear enough, if not tell me and I'll try again! Thanks in advance PD: I posted this in the ASP.NET and Design and Architecture forums, I apologize if this is not ok and you're free to delete one of them.
-
Hi, I'll make it short and clear (I hope). We have two teams developping our product, the R&D and the 'Integrators'. I'm not sure how the Integrators are called in english, maybe TPAM (Third Party Application Maintenance), anyway, let's say that Integrators = People working on the base product, adding or changing functionalities for a specific customer. And the R&D team beeing in charge of doing what's common to all of them (the customers). The R&D team is in charge of developping functionalities available to all our customers, and the other team only does specific developments for specific customers. The problem we're dealing with is that both teams may develop on the same web pages, controls, business logic etc. What happens is that our Release Manager deploys what the R&D team has been doing in some sort of common workspace, and he can't be aware of what's from one team or another, so a lot of times, the Integrators work is lost and our release manager spends hours finding the 'lost changesets' and re applying those modifications. We're need to solve this problem and what we came with far now is to develop some sort of API exposing all the common asp.net events (page_init, load, render, etc.), we also should fire events when entering/exiting BL and DAL functions allowing the Integrators to develop 'manually', maybe injecting some asp.net code into the existing pages, also some code behind, javascript, etc. I'm not really sure if this is a reasonable idea or not, we've just been thinking for like 10 minutes and I wondered what did you recon in this kind of situations. This is just an idea, because they may develop everywhere... Web, BL, DAL and Database (we have a project for that). Just to be clear, we're developing a product, I'm not sure how it's technically called in English but our application will keep growing over time so we really need to do this right otherwise it will cost us a lot of time and money to correct that later when we'll have people using our 'API' (I'm calling this an API but I may be wrong about that) Anyway, we're stuck here, I hope I was clear enough, if not tell me and I'll try again! Thanks in advance PD: I posted this in the ASP.NET and Design and Architecture forums, I apologize if this is not ok and you're free to delete one of them.
_Zorro_ wrote:
The problem we're dealing with is that both teams may develop on the same web pages, controls, business logic etc
First problem is right there. Those components probably should not be treated the same in terms of Professional Services (PS) (customization for different clients.) Commonly the business logic will have a standard API, which the PS can either add to or replace. Replacement is an option and one that should probably be avoided. A plug in architecture can enhance the above by assuming that functionality will be replaced while provide a default functionality ONLY if a replacement isn't found. For the GUI it is often only a replacement, either complete or plugin (but I have almost no GUI experience so other options might exist.) But regardless I think you need to have an explicit strategy for business objects and a different one for GUI even if it seems like they overlap. All of that is a design/architecture problem only and not build/install. For install/build ALWAYS uses the following idiom. 1. Lay down the base product. 2. Lay down the customer (PS) product on top.
-
_Zorro_ wrote:
The problem we're dealing with is that both teams may develop on the same web pages, controls, business logic etc
First problem is right there. Those components probably should not be treated the same in terms of Professional Services (PS) (customization for different clients.) Commonly the business logic will have a standard API, which the PS can either add to or replace. Replacement is an option and one that should probably be avoided. A plug in architecture can enhance the above by assuming that functionality will be replaced while provide a default functionality ONLY if a replacement isn't found. For the GUI it is often only a replacement, either complete or plugin (but I have almost no GUI experience so other options might exist.) But regardless I think you need to have an explicit strategy for business objects and a different one for GUI even if it seems like they overlap. All of that is a design/architecture problem only and not build/install. For install/build ALWAYS uses the following idiom. 1. Lay down the base product. 2. Lay down the customer (PS) product on top.
Thank you jschell, What you’re describing about the BL is more or less what we started. We made a project where we allow other developers to override the implementation of our functions. If we find that/those DLLs then we use theirs otherwise we use ours. It works great actually. But the main concern is the UI. We do not want to have to maintain a lot of duplicated (replaced) pages. What we were thinking was to expose some events and let them write their code dynamically. It would be interpreted at runtime. What do you think about that solution? Do you see any inconvenient I may be not anticipating? Thanks again.
-
Thank you jschell, What you’re describing about the BL is more or less what we started. We made a project where we allow other developers to override the implementation of our functions. If we find that/those DLLs then we use theirs otherwise we use ours. It works great actually. But the main concern is the UI. We do not want to have to maintain a lot of duplicated (replaced) pages. What we were thinking was to expose some events and let them write their code dynamically. It would be interpreted at runtime. What do you think about that solution? Do you see any inconvenient I may be not anticipating? Thanks again.
_Zorro_ wrote:
What do you think about that solution?
Absolute best way to generalize something is to start from existing examples. Presumably you have such examples. You can divide them into categories. 1. Those that are always changed (or almost always) 2. Those that are sometimes changed. 3. Those that seldom are. The first case requires a relook in terms of architecture/design. It could be that the base functionality is just wrong, or that there are easily defined pluggable areas that would make it obvious. The second case is harder in that it might require a more flexible look or it might just be leave it as it is. The last case is easist, it must always be written fresh as an overlay.
-
_Zorro_ wrote:
What do you think about that solution?
Absolute best way to generalize something is to start from existing examples. Presumably you have such examples. You can divide them into categories. 1. Those that are always changed (or almost always) 2. Those that are sometimes changed. 3. Those that seldom are. The first case requires a relook in terms of architecture/design. It could be that the base functionality is just wrong, or that there are easily defined pluggable areas that would make it obvious. The second case is harder in that it might require a more flexible look or it might just be leave it as it is. The last case is easist, it must always be written fresh as an overlay.
-
Hi, I'll make it short and clear (I hope). We have two teams developping our product, the R&D and the 'Integrators'. I'm not sure how the Integrators are called in english, maybe TPAM (Third Party Application Maintenance), anyway, let's say that Integrators = People working on the base product, adding or changing functionalities for a specific customer. And the R&D team beeing in charge of doing what's common to all of them (the customers). The R&D team is in charge of developping functionalities available to all our customers, and the other team only does specific developments for specific customers. The problem we're dealing with is that both teams may develop on the same web pages, controls, business logic etc. What happens is that our Release Manager deploys what the R&D team has been doing in some sort of common workspace, and he can't be aware of what's from one team or another, so a lot of times, the Integrators work is lost and our release manager spends hours finding the 'lost changesets' and re applying those modifications. We're need to solve this problem and what we came with far now is to develop some sort of API exposing all the common asp.net events (page_init, load, render, etc.), we also should fire events when entering/exiting BL and DAL functions allowing the Integrators to develop 'manually', maybe injecting some asp.net code into the existing pages, also some code behind, javascript, etc. I'm not really sure if this is a reasonable idea or not, we've just been thinking for like 10 minutes and I wondered what did you recon in this kind of situations. This is just an idea, because they may develop everywhere... Web, BL, DAL and Database (we have a project for that). Just to be clear, we're developing a product, I'm not sure how it's technically called in English but our application will keep growing over time so we really need to do this right otherwise it will cost us a lot of time and money to correct that later when we'll have people using our 'API' (I'm calling this an API but I may be wrong about that) Anyway, we're stuck here, I hope I was clear enough, if not tell me and I'll try again! Thanks in advance PD: I posted this in the ASP.NET and Design and Architecture forums, I apologize if this is not ok and you're free to delete one of them.
On my organization, we're doing the same thing as you do: Develop a product (core), and at the same time provide customization (integration). First of all, we have several environments per each customer. Development, Test, and Production. Development environment is for developers, Test for testers and Production for customers. Easy enough! Plus when we do a deployment in either Test or Prod, we first get the core, and then overlay the changes. And that overlay-ed source is installed in the environment. So the changes doesn't get lost. We need the Test environment between Dev and Prod because Dev is frequently changing, and not stable enough for testing, and we can't do whatever-we-want in the Prod environment. For our customization's (integration for you), we have a set of Dev/Test environments per customization project. No matter how many APIs you develop, your problems will remain there until your two teams develop in the same environment.