Angular: Platform for building mobile and desktop web applications.
Backend: Refers to the server-side of an application.
Command Prompt: Is a command line interpreter application which is present in most Windows operating systems.
Debugging: Process of detecting and removing existing or potential errors in a software application.
Frontend: Refers to the client-side of an application. It means, the part of a website the user interacts with.
Java helpers: Set of utilities whose function is to emulate PowerBuilder functionality into Java. Were developed using an Observable pattern through Aspects.
Maven: Software project management tool for Java projects. It is based on the POM (Project object model) concept.
Spring: Framework which provides comprehensive programming and configuration model for java applications.
Tomcat: Software used to deploy Java Servlets, JavaServer Pages, Java Expression Language and Java WebSockets technologies.
WebMap: Platform to transform Windows desktop apps to web and cloud.
Observable Pattern: Most important object in the Java Helpers application environment that allows changes made upon each object to be detectable, and the state of each object to be persisted during the lifetime of the application.
Aspect Oriented Programming: Based on Aspects, a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns. It adds additional behavior to existing code to detect changes on the objects. The Aspect is a modularization of a concern that cuts across multiple classes, for example the Transaction Manager.
JSON: Format to serialize objects that communicate between Frontend and Backend. To avoid sending complete complex objects on each request, only the changes to properties detected are serialized, these are also known as "Delta".
ObjectStateInterceptor: Process in charge of intercepting setters and/or new method invocations. Through the setter for example we know that a property value changed, and it needs to be serialized and sent to the server for processing. The ObjectStateInterceptor executes a code before (the additional behavior) to detect those changes and do the serialization process.
Weaving Mechanism: Weaving is a mechanism that performs some of the changes required so the code can be run on web environments.
State of the Application: When the object state changes in the frontend, only the properties that changed are sent back to backend for processing. This is a WebMap trademark mechanism. This mechanism provides a better performance between each request/response and reduce the session size.
Annotations: Attributes added to the class and required properties in order to let the weaving mechanism inject some code during the compilation process. The most important annotations on the Java Helpers are:
@WebMAPStateManagement: handles state of the object, detect changes over the object.
@WebMAPForceSync: this one forces a change detected from backend to frontend even if the value is the current property value.
@WebMAPDataAccess: initialize a data access transaction, when calling a method with this annotation.
@WebMAPIgnoreStateManagement: used when it's not necessary to know or detect changes over an specific object.
@WebMAPSharedStateManagement: handle state of shared variables, detect changes over shared variables.