Recents

GeneXus Server - Introductory videosUnofficial Content

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 core 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 when 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 travel a lot, so it’s quite common for them 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 method means each developer has a local KB with part of the application (i.e. 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 the solution and each developer updates, what updates must be sent to each developer, when these updates must be sent, what to do in case of conflict (two developers changed the same object), etc. 

Neither Brad nor Angie wanted to be the administrator, so this methodology was discarded too. 

What to do? 

GeneXus Server

They decided to use GeneXus Server; this is a server where Developers can 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 that is complete and wants to share it or, when 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 an object, new and removed ones) are sent to the GeneXus Server. In GeneXus Server, 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 GeneXus Server, 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 GeneXus Server: 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 the developers are not the only ones involved, but anyone else could subscribe to this service to receive the information. 

Conclusion 

They decided to use GeneXus Server to develop the solution together. 

Note: The geographic distribution is trivial to work with GeneXus Server; 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 GeneXus Server idea and how it works, so the sample KB is incredibly simple. However, the same concept applies to bigger developer groups and larger 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 GeneXus Server; to do that she used the “File/New/Knowledge Base From server”.

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

Angie creates Customer transaction and gets updated from the server.

[31523]

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