Versión en español/Spanish version

Introduction

These videos show how to work in a team using GeneXus and GeneXus Server (GXserver) and the basic operations involved: send Knowledge Base to Server, create a Knowledge Base from the Server, commit, update, etc.

Scenario

Brad had started developing a basic Invoicing application and a new developer, Angie, joined the project. Therefore, Brad and Angie will develop the Invoicing application together. 

Before starting to work together, they discussed different alternatives on how to work together. 

Multiuser 

Angie works in NY and Brad works in Florida. The communications between their offices are “good enough”; however both use to travel a lot, so it’s quite common to get connected to the internet from all around the world. 

In this scenario the internet connection could be available or not, therefore the multiuser option, both working together over the same KB, was discarded. They need the KB locally to avoid this kind of problems. 

Traditional methodology (i.e. kernel KB, each developer a different kb and finally a consolidated KB) 

This methodology means each developer has a local KB with part of the application (i.e. an objects set) and the knowledge is shared through the Knowledge Manager. Once a developer wants to share something he/she must distribute this knowledge (XPZ file) and the other developer consolidates this knowledge.

Where is the whole KB? 

This KB is known as “the consolidated KB” and means one developer must be “the consolidated KB administrator”. He/she receives the XPZ files from each developer and consolidates them into the consolidated KB. 

The administrator sends the updates to each developer through the same way (XPZ files). 

The problem with this methodology is the need of the administrator role, the knowledge this administrator requires about the solution and each developer updates, what updates must be sent to each developer, when these updates must be send, what to do in case of conflict (two developers had changed the same object), etc. 

Nor Brad not Angie wanted to be the administrator, so this methodology was discarded too. 

What to do? 

GXserver 

They decided to use GXserver, this is a server where to store KBs. 

How does it work? 

This is just an overview, for further information please check GeneXus Server.

Each developer works on a personal copy of a Knowledge Base (i.e. no connection required and no interaction with other developers), when he/she thinks there is something he/she has done is complete and wants to share it or, there is something someone else has shared and he/she wants to see it, then a commit or update operation must be done respectively. 

When a developer executes a “commit” operation, changes made to his/her personal Knowledge Base (i.e. changed object, new and removed ones), are sent to the GXserver. In GXserver, this knowledge is consolidated with the existing one and feedback about this operation is given to the developer doing the “commit”. 

The “update” operation is, somehow, the opposite of a "commit" one. It applies all changes committed by other developers to the developer’s personal Knowledge Base. This knowledge is consolidated in the personal KB and feedback is given to the developer doing the “update”. 

Using GXserver, each developer has a personal KB and its advantages (performances, known status without unknown changes from another developer, etc.) and the whole solution is being built in the GXserver. 

More advantages are obtained using GXserver: to add a developer is just to “enroll” this developer to the server, the whole solution status is well known and easily shareable and accessible, RSS services are provided and not only the developers involved but anyone else could get subscribed to this service to receive the information. 

Conclusion 

They decided to use GXserver to develop the solution together. 

Note: The geographic distribution is trivial to work with GXserver; one developer is enough to reach great advantages with its use.

Let’s see how they did. 

This is just a “sample” to explain the GXserver idea and how it works, so the sample KB is extremely simple. However, the same idea is applicable to bigger developers groups and bigger KBs too.

Brad starts sharing his KB. To do this he just used the “File/Send KB to Server” option. After that he updated the knowledge, adding an attribute, just to check all works fine.

Angie starts to work creating her KB from GXserver; to do that she used the “File/New/Knowledge Base From server”.

Brad adds "default" rule to Invoice transaction and sends his KB to GXserver using "Knowledge Manager /Team Development/Commit" option.

Angie creates Customer transaction and gets updated from server.

Brad keeps his KB synchronized with GXserver downloading Angie’s changes.