TAFJ-R14 1

TAFJ-R14 2
 One of the highlights of the T24 design architecture is its run-time technology
independence. T24 is available on three platforms C, Java and .Net.
TAFC – Temenos application framework C
TAFJ – Temenos application framework Java
TAF.Net – Temenos application framework .Net

Interaction Framework – Framework for varied user interfaces like ARC Mobile, ARC
IB, T24 Browser, Design Studio, TCIB etc. to communicate with T24
Component Framework – Framework to componentize T24 into independent
implementable components.
Integration Framework – Framework for T24 components to integrate and
communicate with non-T24 banking systems.
Platform Framework – Framework to make T24 independent of the platform to utilize
the full functionality provided by the platform.

TAFJ-R14 3
 • TAFJ (Temenos Application Framework Java) is our proprietary runtime and
compiler for jBC code, written in 100% java. It allows compiling and running jBC
programs on Java. jBC code is parsed by the TAFJ parser and compiled by javac
compiler and translated into equivalent Java classes. The java compliant files
generated can then be run in a JVM taking the full advantage of Java functionality
like portability, platform independence etc.
• TAFJ has been written specifically for T24 needs thereby allowing T24 to be
deployed on J2EE application Servers. This enables T24 to harness the full
functionality of J2EE application servers like connection pooling, threading, security
etc.
• TAFJ also manages the connectivity on JDBC compliant databases like Oracle,
Microsoft SQL Server, DB2, DB2 – zOS, H2.

TAFJ-R14 4
 The TAFJ T24 architecture can be understood from this diagram
• Any T24 source code(*.b) can be compiled into java classes(*.class) on TAFJ. The
entire T24 source code is packaged into jar files and deployed on a J2EE server.
When a request comes to T24, the required .class files are executed on the TAFJ
runtime. TAFJ uses JDBC drivers to connect to JDBC compliant databases like
H2, Oracle, SQL server, DB2, DB2-zOS.
• TAFJ runtime comes with several useful and easy to use tools to manage the
runtime and database. For e.g., to import data from a jBase database into oracle
database there is a tool called DBImport.
• All the runtime configurations (for eg, the URL of the database to connect to,
compiler settings, the location of the runtime user directory etc. ) are specified and
managed using property files. These are simple text files and can be changed
easily. To connect to a different database, all that we need to do is change the
database property values in the property file and the associated TAFJ project will
behave accordingly.
• TAFJ uses log4J loggers and maintains extensive logs.
• Unlike TAFC, TAFJ makes use of the OS print manager and the JVM print
mechanism and hence it is easy to configure printers. TAFJ does not have a
spooler of its own like the TAFC spooler.
• TAFJ provides a lock manager (like the jdls in TAFC) for database lock
management.
• TAFJ also has the capability of redirecting all in and out streams to a remote client
console.

TAFJ-R14 5
 The real excitement about TAFJ from a developers perspective is the ability to work
with the eclipse IDE and from a clients perspective is the platform independence. The
TAFJ workflow is as follows :

The developer writes code for T24 using jBC programming language(alternatively
referred as Basic in this course) on the eclipse IDE. This is enabled by the TAFJ plugin
in eclipse. The TAFJ lexer-parser-tree walker translates standard jBC code into
equivalent Java classes and generates the source code(.java), which is then compiled
into a java compliant bytecode(.class). The .java files are deleted after compilation.
The bytecode can be run on any JVM thus making T24 platform independent. Local
T24 developments can be done in pure Java too.

[Note: To execute T24 on TAFJ, we need only the jre. However if you need the
compiler, then you must have JDK in your machine. JDK = JRE + Compiler. ]

TAFJ-R14 6
 The TAFJ Environment can be summarized in the diagram shown
1. A Compiler to compile basic code into bytecode
2. A Runner to execute compiled basic files.
3. A Lock manager to manage application locks
4. Database management tools (DB Tools) to query and manipulate database tables.
H2, DB2, DB2(zOS), Oracle, SQL databases are supported in TAFJ. The tools
also provide the ability to import tables and records from one database into
another, check the database integrity and compare T24 data in two databases. Till
R13, we could only import a J4 file into a RDBMS.
5. Works with eclipse IDE to develop, compile, debug and execute T24 basic code.
The RTC plugin can be incorporated into the eclipse IDE for change set
installation (*.b and *.d)into the TAFJ runtime.
6. Distribution tools for packaging java classes into component jars for distribution.
7. Update and upgrade tools to keep your T24 on TAFJ up-to-date.
8. TAFJ - EE application which can be deployed on jBoss, WebSphere and a
Weblogic application server

TAFJ-R14 7
TAFJ-R14 8
 If we compile T24 on TAFC on a windows platform then we can execute it only on
Windows. (even on Z/OS) However Java programs are popularly known as write once
and execute anywhere. That makes T24 on TAFJ as completely platform independent.
A platform is the hardware and software environment in which the program runs. Any
program that needs to be executed on a platform must be converted into machine
instructions understandable by that platform. When developers write T24 programs on
TAFJ and compile it, the code is not directly converted into machine instructions but it
is compiled into ByteCode. Bytecode is not machine instructions that any platform like
Windows, Unix will understand it directly. This Bytecode is understood by Java made
Virtual machines. Java Virtual Machines (JVM) interprets the Bytecode into machine
specific instructions so that platform can understand it. Java Virtual Machine (JVM)
plays a key role in making the Bytecode understandable to any underlying platform
thus makes the Bytecode platform independent. Thus a T24 compiled on Oracle JDK
on Windows will seamlessly run on an IBM JVM on Unix
Thus,
• Java is a platform independent.
• Java programs are compiled into Bytecode which are platform independent.
• Bytecode are executed on Java Virtual Machines (JVM).
• Java Virtual Machine (JVM) is platform dependent.
• JVM needs to be pre-installed on the machine for executing java program.
• There are different version of JVM available in the market to support variety of
platform.

TAFJ-R14 9
 TAFJ uses only Open source softwares for all 3rd party requirements, like H2, jBoss,
JDK, eclipse etc. The competitive advantage that an OSS gives by allowing
customization of code to suit our company’s needs is a significant reason for using
them in addition to the low cost of ownership. A T24 on TAFC requires renewal of T24
as well as MSVC licenses, whereas Java is open source. Support for other
contemporary market technologies is easier with TAFJ rather than TAFC. For
example lets presume a client wants to use MySQL another open source database
instead of jBase, Oracle, SQL server, DB2, derby and derby(embedded) which are the
ones that we support currently. On a TAFC runtime, we have Direct connect drivers
(DCD) for Oracle, SQL Server and DB2. A great volume of programming effort is
required to newly create a DCD for MySQL. Whereas on TAFJ, since we use JDBC
drivers, its only a matter of very few lines of code to write for performance
improvement.

TAFJ-R14 10
 Clustering Application server is a very common implementation. T24 on TAFJ is
deployed inside an Application server like jBoss, Websphere or Weblogic. Hence
when the application server is clustered, T24 application is also automatically
clustered. However in the case of TAFC, since T24 is outside an AS, Application
server clustering does not entail T24 clustering.

TAFJ-R14 12
 You will learn how to install TAFJ
a. From a Dev Image
b. A setup from scratch

TAFJ-R14 16
 On extracting the Dev Image, a TAFJ area is created automatically. Ensure the dev
image is extracted in the D: drive since the scripts in the area are hard coded to this
drive. A folder called Temenos gets created in the D: drive on extraction. The folder
structure of a TAFJ area is shown in the slide.
DEV – contains files related to the current Dev stream for eg R15.
TAFJ folder – contains tafj runtime libraries and files. The path to this
folder is set as the TAFJ_HOME environment variable.
T24 folder – contains T24 data files and libraries. The path to this
folder is referred to as T24_HOME
IDE – Eclipse and EDS (enterprise design studio) software
3rdparty – contains 3rd party softwares used in TAFJ – H2 database, jBoss and java
development kit.

In the T24 folder, you will find scripts to start Eclipse IDE and H2 database. Eclipse is
used to write, compile, debug and execute jBC code for T24. The TAFJ plugins in
eclipse enable this. T24 data is stored in the H2 database.
Double click on eclipse.cmd to open the eclipse IDE and start_H2.cmd to start the H2
database. CMD opens a command prompt, where you may run tafj_Shell.cmd to
launch a TAFJ shell i.e. it sets the environment to execute tafj commands like tShow,
tDiag etc.

TAFJ-R14 17
 Let us understand TAFJ_HOME in detail. This folder contains the TAFJ Runtime files
Appserver - Application server configuration files are kept here. These files are necessary for
deploying T24 on AS like jboss, Websphere, Weblo, etc.
Bin - executable scripts (tRun, tCompile, ...).
CodeCoverage – contains cobertura jars for calculating and reporting test coverage. Primarily used
in regression tests
Conf - configuration directory where the project property files are maintained.
Data - Contains 2 folders - classes and java. Classes folder holds .class files generated and java
folder holds .java files generated, on compiling a jBC code.
Dbdrivers - drivers of the various databases supported in TAFJ can be found in this folder, for use
if needed.
Dbscripts – when you install a new database instance of say H2 or oracle, you need to run some
stored functions on the database to ready the new database for storing T24 data. These are
available as scripts in this folder, database wise.
Eclipse – contains the tafj plugins which enable jBC coding in eclipse IDE. These must be
linked/added to the plugins or dropins folder of your eclipse software.
Ext - This directory contains all java classes (or jars) ‘extending’ or ‘replacing’ the T24 jBC
subroutines. Additionally this is the folder to keep the external jars like jbossall-client.jar for jboss
which contains all the client class of jBoss, database drivers, component framework jars etc
JMSInjector – Contains JMSInjector to inject OFS into queues - for benchmark
Lib - TAFJ runtime libraries. Regression – contains scripts to perform regression testing.
Doc – TAFJ user guides. Log and log_T24 – end to end runtime logs and T24 logs for

TAFJ-R14 19
 splunk respectively
Samples – sample basic codes TAFJSessionMonitor – contains TAFJ MW42 monitor.
RELEASE – contains code fix info Pom.xml – required for running maven builds

TAFJ-R14 19
<TAFJ_HOME>/data/

/<Project Dir>/ - > The default project directory name. When you create a project in
eclipse, the eclipse builder creates this directory automatically with the project name.
For eg DEV

/<Project Dir>/classes/ - >The default directory where the compiled BASIC goes i.e.,
.class. eg <TAFJ_HOME>\data\DEV\classes

/<Project Dir>/java/ - >The default directory containing the BASIC converted into
.java. Eg <TAFJ_HOME>\data\DEV\java

20
TAFJ doesn’t use Environment Variables. TAFJ setup is based on a properties file.
These files have a .properties file extension. These are known as Property
Resource. The property files contain properties (or parameters) for configuring the
behaviour of TAFJ projects and is available under <tafj_home>\conf directory. Each
property is stored as (key=value) pair of strings, one storing the name of the property
(called the key), and the other storing the value. For eg temn.tafj.jdbc.driver =
org.h2.Driver. All key=value pairs are loaded as Java System Properties.
The following property files are available by default in the conf directory: .default,
.properties, tafj.properties, TAFJ.Trace.properties along with TAFJ.policy.
1. The tafj.properties file is the default TAFJ configuration file. It is similar to the
.profile file in TAFC. By default TAFJ refers to this file for information on compiler,
database, runtime etc. setting. It provides vast information for the development and
runtime environment on TAFJ.
2. You may have multiple projects created in eclipse like DEV, R12,R14 etc. But only
one project is maintained as the default project. The property file name of the default
project is maintained in the file .default. In the TAFJ area shown in the snapshot,
DEV.properties is the default configuration file (instead of TAFJ.properties). This file
has only one entry. This file is useful when you execute tafj commands which expects
a property file name as a parameter, but has not been supplied. Tafj uses the default
property file in such cases.
If the filename in .default is incorrect and does not exist, then TAFJ will automatically
make tafj.properties as the default.
Note : When working with multiple projects in eclipse remember to keep only one
project open at a time. Close other projects.

21
3. You can also define a property file manually. The default property file template is called
“.properties”. If you wish to manually create a different configuration, then instead of
overwriting the default configuration file, you can copy the template and modify the values
as required.
4. TAFJ.policy is a java policy file which define security permissions for the code to run.
5. The configuration settings of the TAFJ logger(log4jlogger) is in the file
TAFJTrace.properties. TAFJ uses the standard LOG4J open source. You can log
information on compilation, runtime, database, execution etc. To change the log
levels(FATAL,ERROR, WARN,INFO, DEBUG) use this file. All log files go to
<TAFJ_HOME>\log
You can keep multiple T24 releases in one single setup of TAFJ. This is done using
property files. Property files can be manually created. Or else when you create a project
in eclipse and toggle it to TAFJ, the project that you create will have an associated
property file with the same name. These configuration files have the extension
“.properties”. In the snapshot shown we understand there are three projects-DEV, R12
and R14, since there are three property files by that name. Whenever you create a new
project in eclipse, the Eclipse Builder plug-in generates new configuration files using the
Eclipse project name. In the DEV.properties file you can point to the Dev T24 area(say
R15) on a H2 database whereas in R14.properties file, you can point to an R14 T24 area
on an Oracle database and make the R12.property file reference an R12 area on MSSQL
Server. Which means when you execute code inside the project called R14, the
R14.properties file is read and the code is executed using the precompiled T24 jars of
R14 and will manipulate the data in the Oracle database, whereas when you execute
your R12 project your code will execute in an R12 area and store the data in an MSSQL
database. Therefore in one TAFJ installation you can have different T24 releases like

22
 R12, R14, Dev etc.

TAFJ-R14 22
To check your tafj installation you can use the tDiag command. The command is
discussed in detail later.

It gives you information about your <TAFJ_HOME>, Runtime Version and many more.

Note that the default project is set as DEV. The .default file by default has the entry
tafj.properties. This has be overridden with DEV.properties, that’s why the default
project is displayed as DEV.

23
TAFJ-R14 24
A TAFJ standalone is nothing but just the TAFJ runtime and the precompiled jars of a
T24 release like R12 along with a backend database. You can run T24 classic in this
setup from a VT100 console.

25
 Use java –version at your command prompt to check the java version installed in your
machine. It should be 1.6 or above. If the version reported is not 1.6 (or above), you
should install it. Java JDK can be downloaded here:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Set-up an environment variable called JAVA_HOME pointing to the root directory of
your java installation. Then, reference JAVA_HOME/bin in your PATH environment
variable.

TAFJ-R14 26
 After unzipping you will notice Patch.xxx and Setup.xxx and a jar file. To do a fresh
TAFJ installation from scratch and not starting from the dev image, then run the Setup.
This will create a folder (name it as TAFJ for convenience) with all the runtime related
files. This folder becomes your TAFJ_HOME.

[Note : For upgrading the runtime in an existing DEV image, we make use of
“Patch_TAFJ.<version>.bat” on windows and “Patch_TAFJ.<version>.sh” for Unix. If
however the upgrade is from a very low version to the recent version , then a
Setup_TAFJ.<version>.bat/sh is advised. ]

TAFJ-R14 27
1. Set your JAVA_HOME to the location of your JDK
2. Run the Setup.xxx.bat file. Specify a location for your TAFJ_HOME. This creates
a folder called TAFJ by default. This folder contains all the runtime files and is
referred to as <TAFJ_HOME>
3. Copy the appropriate H2 database drivers from
<TAFJ_HOME>\dbdrivers\<database> to <TAFJ_HOME>\ext.
[Note: The H2 database version can be identified from the h2<Version>.jar in
<h2_home>\bin. For e.g. - h2-1.3.161.jar]

28
3. Edit your default property file in your new <TAFJ_HOME>\conf. You can identify
the default property file from the .default file. It should be tafj.properties.
4. Note that <tafj.home> is already set to your new <TAFJ_HOME> based on the
directory that you specified when running Setup.
5. Set the precompile path in the property temn.tafj.directory.precompile to the location
of your T24 core libraries.
6. Set your database URL, driver, username and password properties to point to the
H2 database
[Note : The URL description and the specific driver information for each database is
mentioned under the Database Setup section. For H2 it is jdbc:h2.tcp://<host or
IP>:<port No>/<db_name>. The default H2 port is 9082. Since we are starting H2 at
port 9007, the same is mentioned. The database instance name is DEV. For the H2
database that we are using the username is tafj and password is tafj]

29
7. Start your H2 database at port 9007. The sql> prompt suggests that the database
has started.

30
8. Navigate to <TAFJ_HOME>\bin from your windows command prompt and execute
tDiag.

Note that the default project is set as tafj. This is because, the .default file has the
entry tafj.properties. This entry can be overridden and any other project can be made
as the default.

31
9. From a vt100 console execute the command tRun EX to launch T24 Classic.

[Note: Execute tRun from <tafj_home>\bin]

32
10. Setup Eclipse Plug-ins
Once the setup of TAFJ is completed and if you have eclipse v.3.7.x or above
installed, you can simply link the contents of the directory
<TAFJ_HOME>/eclipse/plugins to the directory <ECLIPSE_HOME>/dropins. The
<tafj_home> eclipse plugins are necessary for using eclipse as the IDE for T24
development.
1. a.Create a file <name>.link for e.g., tafj.link in <ECLIPSE_HOME>/dropins.
b.Edit the file tafj.link and add a property key called path=relative path from
<ECLIPSE_HOME> to <TAFJ_HOME>
i.e.
For the directory structure:
+---eclipse
| +---eclipse_3.7 <ECLIPSE_HOME>
| | +---dropins
+---TAFJ

path=../../TAFJ

33
2. Once done, in order to verify that all TAFJ Plug-ins are loaded with eclipse, you can
go in the Eclipse menu:
Help -> About Eclipse SDK, press on “Installation Details”, and Tab: “Plug-ins”. You
must find the tafj plugins shown in the snapshot.

Versioning follows this pattern.

<Release Version>.<Service Pack>.<MonthlyBuild-1>
For eg Version 14.3.0 is R14.SP3 and 15.0.2 is the current dev, march build.
Remember it is Monthlybuild - 1

3. You should also be able to load the TAFJ Perspective.

34
35
36
When you execute a tafj command, a check is made to see if you have used the –cf option with
the command. If the configuration file exists, then the values in the configuration file is used for
execution. If –cf option is not used, then a check is made to see if the .default file exists. If yes,
read .default entry. If the configuration file specified in .default exists then use that file, otherwise
display error.

37
The file .default in the <TAFJ_HOME>/conf directory can be used to set a default
configuration. By default the value in the text file: .default is set to tafj.properties.
The default property file template is called “.properties”. To manually create your
property file, copy .properties into a file called T24_Dev.properties as shown. Then
edit T24_Dev.properties.
1. Set your T24 core libraries path and the database properties as you did in the
previous session.
2. Specify a path where you would store your basic routines in the property
temn.tafj.directory.basic. You can specify multiple directories separated by a :
or ;
3. By convention, the java and class path for TAFJ of a project have to be set under:
<TAFJ_HOME>\data\<ProjectName>\java and classes. The related properties
are temn.tafj.directory.java and temn.tafj.directory.classes. For e.g.,
<tafj.home>\data\T24_Dev\java
4. Edit your .default to now refer to T24_Dev.properties.
[Note: In your Dev area, the .default is set to DEV.properties instead of Tafj.properties
because the DEV project in eclipse has been made the default project]

38
tafj.home - points to the TAFJ folder in your tafj area which contains the runtime
libraries and other related files.
temn.tafj.directory.basic, folder location to all your basic source files. You can
specify multiple paths with the separators “:” or “;”.
temn.tafj.directory.insert, folder location where the INSERT files for your project is
kept. The Insert file can be in the basic source folder itself or in a different path.
temn.tafj.directory.java, folder location where the java source files should be
generated. This property is mandatory and you can set only one path.
temn.tafj.directory.classes, folder location where the classes files should be
generated. This property is mandatory and you can set only one path.
temn.tafj.directory.precompile, refers to the folder location where the precompiled
class files are kept. Usually contains the precompiled t24 class files required by your
t24 basic code. Multiple paths can be specified using the separators. The precompile
paths are overridden by ”temn.tafj.directory.classes” paths. For e.g. you have a
class TEST.SUB in the precompile path. You compile a TEST.PRG which inturn calls
TEST.SUB. In this case the TEST.SUB in the precompiled path will be called. Now if
you generate a new TEST.SUB in classes path, then TEST.PRG will not call the
TEST.SUB in the precompile path. Instead it calls the one in the classes path. This
path could be a folder or JAR file.
[Note : The preferred location for T24 precompiled is <t24_home>/lib in your Dev area]

39
TAFJ-R14 40
TAFJ-R14 41