Programming Language Design for Financial Services (ITECH5403)

This document details the design of a programming language, named "2D pokemon jirachi", tailored for financial services. The language is based on Java, aiming for platform independence and ease of use, drawing inspiration from JAVA's features. It introduces unique memory management, distinguishing between stack and heap memory, similar to Java but with simplifications. The design emphasizes simplicity, orthogonality, and data type choices, including custom data types like "num", "info", "judge", "sim", and "small". The syntax is inspired by C++, and the project justifies design decisions based on suitability for financial applications, including server-side applications and transaction processing, addressing Java's potential shortcomings by incorporating functional programming and lambda expressions to enhance code conciseness and performance. The design also addresses features like automatic memory management and exception handling. The document provides code examples and discusses the advantages of the designed language for the financial industry, including its object-oriented features.

Programming
Programming Languages
Student Name
University Name
Unit Code
0

Programming
Contents
Name of code.................................................................................................................1
Introduction of code.......................................................................................................2
Language purpose..........................................................................................................2
Interpretation/compilation method, scoping features and memory management..........3
1. Server application for financial services department.................................................6
Specification and rationale for major language features................................................6
Simplicity.......................................................................................................................6
Orthogonality.................................................................................................................7
Data types.......................................................................................................................8
Syntax design...............................................................................................................10
Support for abstraction & Expressivity........................................................................12
Type checking, Exception handling and Restricted aliasing.......................................15
Discussion....................................................................................................................17
Great portability...........................................................................................................17
"Object-Oriented".........................................................................................................17
Appropriate for the distributed computing...................................................................17
Good performance........................................................................................................18
Robust, stifled in bud...................................................................................................18
Multi-threaded processing capability...........................................................................18
References....................................................................................................................19
1

Programming
Name of my code
I named my design language as 2D pokemon jirachi. This means we may bring this code into
your stamp. It is easy to use as well as learn.
Introduction of code
2D pokemon jirachi is a language based on the JAVA. In this design, it will get many
advantages of the JAVA. It seems that Code is independent of the platform on Windows NT,
Windows9 x, Linux and Solaris, MacOS as well as other different platforms. User may use
similar code. The features of "write once, and run anywhere" make it extensively used on the
Internet. Simultaneously, in design, this is likewise a series of language compilers. The Java
language is a decoded language. Compared to C/C ++ language, programs inscribed in the
Java language are inefficient and slow to execute. But 2D pokemon jirachi can achieve the
same efficiency as C/C ++. At the same time, it is based upon JAVA so that it may
independently run on very small machines. Because, 40 k may have one of the simplest
interpreters, even with very basic threads and normal library assistance, just add 175 k.
Choice and justification of interpretation/compilation methods
This language was originally designed for retail use in languages, so it needs to be clearer and
clearer than Java code and can utilize smaller devices, for example, pos terminals.
I am assured that its novel feature lies first in it (Camenzuli&Schoenmakers, 2014).
These novel features comprise:
1) Provide automatic administration of the memory, programmers required to allocate as well
as release memory in program, awful memory allocation errors will not bother you (Seacord,
2016);
2

Programming
2) Along with C/C++ language in confusing as well as error-prone "pointer," other methods
can be used to make up;
3) Avoid confusion between assignment statements (for example, a = 4) and rational
operation statements (for example, a = = 4);
4) Elimination of multiple legacies of composite services.
The mechanism is the reason why I select JAVA syntax powerful, simple, from the web to
desktop, omnipotent embedded. Comparing these languages with C++, C Java is extremely
simple, removing Java pointers, very well understood, automatic garbage collection device is
also extremely good, since the start-up performance of JDK1.5 has been greatly enhanced, in
addition, there is such a call: Make Java rather than the basic language of C (Olsson &
Williamson, 2015). These Javas are enough to exemplify the benefits of simple to learn and
use. Next, the power of Java, I stated above, the introduction of EJB 3.0 makes the Java first
choice for big projects. The function of the J2ME in a mobile game advancement was also
unusable (Chou, 2013).
More importantly, as a financial graduate, JAVA is a single thing I have ever touched.
Thus here, I will completely extend the mechanism of JAVA memory:
2D pokemon jirachi divides memory into 2 types: one is a stack memory, and other is the
heap memory. Some of the basic types of variables as well as object reference variables
defined in a function are a function in stack, memory distribution. When the variable is
defined in a code block, 2D pokemon jirachi will allow memory space for variables in the
stack, when the variable is exceeded. Range (for instance, in function call function B, in the
function described in the variables A, BB, the extent of the variable A is just in function after
3

Programming
the function is run, the B variable A is inevitably destroyed. Its memory is reprocessed. The
allocated memory space is automatically released by 2D pokemon jirachi for the variable, and
memory space may be used instantly by another one. Heap memory is utilized to store the
objects as well as arrays, formed by novel memory allocated in a heap, and managed by the
Java VMT Garbage Collector. Create an object or array in a heap, or a distinct variable in the
stack, so that value of this variable in the stack is equivalent to the object or array in the heap
memory address. A variable stack is an object or array reference variable, which may be in
the program. Use, access the heap object or array in the stack in the reference variable; the
reference variable is the name of an object or array (Minarova, 2013). Reference variables are
usual, described in stack distribution, reference variables in a program afterward it has run to
the outside of scope is released. And the array is allocated in a heap and the object itself, even
if the application is using the novel array or the block of object's code, the array and the
object itself will not be freed. The array and the object are not referenced. It becomes trash,
not use, but yet occupies the memory space, and collects with the garbage collector (release)
at an uncertain time (Chrysikou, 2018).
Since the mechanism is similar, I will give a JAVA instance to describe it.
classPerson{
String name;
int age;
publicvoid tell(){
System.out.println("name:"+name+"age:"+age);
}
4

Programming
}
publicclass Test01 {
publicstaticvoid main(String[] args) {
Person per=new Person();
}
}
Each object is instantiated in the above application, and the object needs to open space in
memory during the instantiation process, including stack memory and memory (STUMP &
FU, 2016). As the design of the retail business code, the mandatory range may be
appropriately reduced to attain its simplicity as well as ease of usage. In the numerous
application areas of JAVA, the user just needs to choose two as well as borrow some code to
achieve (Inoue, 2014).
1. Server application for the financial services department
Java is extremely powerful in the financial services business. Many international investment
banks, for example, Barclays Bank, Citigroup, Goldman Sachs, and Standard Chartered Bank
use Java to inscribed back -end and front -end electronic trading systems, verification and
settlement systems, and additional data processing systems. Java is also broadly used to
inscribe server-side applications. Most of the server applications have no front-end, accept
data directly from the upstream server, and then send it to a downstream process after
processing. The Java Swing is utilized to generate a fat consumer GUI for the traders,
howeverc# now occupies Swing quickly in all features of sharing, and Swing is rare (Järvi&
Freeman, 2015).
5

Programming
2. Transaction application
The third-party transaction applications are also written in Java in a big part of the financial
services business. Murex is broadly used for numerous connections amid Banks, inscribed in
Java (Goldman, 2004).
Specification & rationale for the major language applications features
Simplicity
Java code has a long-standing repute, in part due to its simple project object-oriented
execution style. In several languages, the classic "Hello World" program example can be
implemented with an only a single line of code containing no over 20 characters. In Java,
along with the class definitions included in the chief method, you also require to involve
method call in the main method, through the System. The println () the string is to print to the
terminal. Even if in use of a technique of the minimum qualifier, semicolons, and brackets,
and remove all the Spaces are all the limitations of cases, "Hello World" program is likewise
required at least 86 characters (Kim, Viswanathan, Kannan, Lee & Sokolsky, 2016). For
readability, plus indentation and whitespace, there is not any doubt that the Java version of
"Hello World" program is a long-lasting effect (Fajuyigbe, Onibere & Ekuobase, 2010).
The long part of Java code should also be attributed to the fact that the Java community will
be explanatory instead of simple as its norm. Thus, I will enhance the JAVA language of this
vulnerability. 2D pokemon jirachi will present Functional programming as well as Lambda
expressions. With the launch of the Lambda expressions in Java, a knowledge of these novel
features of developers requires the ability to at least read content written by other developers.
These characteristics may also bring real benefits that can influence the design of the
6

Programming
concurrent systems for improved performance. This editorial focuses on how to utilize these
means to inscribe a concise code(Latifah, Saddhono&Wardhani, 2017).
Orthogonality
Design of the 2D pokemon jirachi needs to meet orthogonal design. The Orthogonality means
higher consistency and lesser coupling. To this end, orthogonality may be utilized to measure
the reusability of a system(Straßer&Rothermel, 2015). Therefore, how to do it, in my design,
it must satisfy four points:
 Remove duplication
 Parting of apprehensions
 Reduce the extent of dependence
 Depend on the constancy of direction (Dorin, 2018)
Data types
In design, 2D pokemon jirachi is the same as Java and has 2 data types.
 Reference data type
 Built-in data type
Java supports 8 built-in data types. A built-in type pre-described by Java language as well as
termed in Java keyword. (int, boolcan, double, byte, char, float, short, long,).
In the 2D pokemon jirachi, we only have five types including all eight Java.
1. num:
The num data type is dual precision, 64, up to the standard of IEEE 754 floating point
numbers;
The default type of num type floating point number;
The num type also cannot say accurate values, such as currency;
7

Programming
The default is 0.0 d;
Example: num d1 = 123.4.
2. info:
Infi type single 16-bit Unicode characters;
The minimum value is' \ u0000 '(0);
Maximum is \ 'uffff' (i.e., 65535);
Infi data type can store any character;
Example: info letter = 'A'.
3. judge:
Said judge data type information;
There are only two values: true and false;
This type is only used as a symbol for recording true/false information;
The default value is false.
Example: Judge one = true.
4. sim:
Sim data type is eight, a symbol, in two's complement representation of the integer;
The minimum value is - 128 (- 2 ^ (7);
Maximum is 127 (2 ^ 7-1);
The default value is 0;
Sim type used for large array to save space, main instead of integer;
Example: sim a = 100, sim b = - 50.
5. Small:
A small data type is a 16-bit, signed in two's complement representation of the integer
The minimum value is - 32768 (15) - 2 ^;
8

Programming
Maximum is 32767 (2 ^ 15-1);
A small data type can also save space as a byte.
The default value is 0;
Example: the small s = 1000, small r = - 20000.
In 2D pokemon jirachi, reference type variables are very alike to C/C++ pointers. The
reference type points to the object that references the object variable. These variables in the
statement are stipulated for a specific type, for example, Pubby, Employee, and so on. Once
the variable is declared, the type cannot be altered (Li, Dai, Xu &Er, 2013). Object, an array
is a reference data type. The default value for all reference types is null (Chiba, 2008).
Reference variables can be utilized for any reference that is well-matched with that type.
Instance: Squirtle squirtle {lol Demacia}
Syntax design
In a grammar design, because of the complexity of JAVA syntax as well as variability, I chose
to utilize C++ syntax for basic design, as C++ must be more flawless than JAVA.
9

Programming
So syntax illustration:
classCool{// Declares class Cool
simx;// Private Member variable
public:
Cool():x(0)// Constructor for Cool; initializes
{}// x to 0. If the initializer were
// omitted, the variable would not
// be initialized to a specific
// value.
simBulbasaur(simi){// Member function Bulbasaur ()
return3*i+x;
}
};
Coola;
// declares a to be a Cool object value,
// initialized using the default constructor.
// Another constructor can be used as
Coola(Charmander);
// or (C++11):
Coola{Charmander };
Coolb=a;
// copies the contents of a to a new Cool object b;
// alternative syntax is "Cool b(a)"
a.x=5;// modifies the object a
Cool*c;
// declares c to be a pointer to a
// Cool object (initially
// undefined; could point anywhere)
c=newCool;
// binds c to point to a new Cool object
Cool&d=*c;
// binds d to reference the same object to which c points
c->x=5;
// modifies the object referenced by c
10

Programming
a.Bulbasaur (5);// invokes Cool::Bulbasaur () for a
c->Bulbasaur (5);// invokes Cool::Bulbasaur () for *c
std::cout<<d.x<<std::endl;
// outputs 5, because d references the
// same object to which c points
Support for the abstraction as well as Expressivity
In the object-oriented concept, all the objects are described by classes, but conversely, not all
the classes are utilized to define objects. If the class doesn't have sufficient info to define a
particular object, then this class is an abstract class. In addition to the abstract class, other
functions can still be instantiated, member variables, member methods, and constructor
access methods and public classes. Because abstract classes cannot instantiate objects,
abstract classes must inherit and be usable (Balland, Moreau & Reilles, 2012). So, in my
view, PokenmonJ is only for retail creation, and I chose not to let it support abstraction
compatibility. This can significantly reduce the trouble of the 2D pokemon jirachi code, in
addition to the simpler applicability (Long, 2013). In terms of expressiveness, 2D pokemon
jirachi is the perfect inheritance polymorphism of Java. Three essential terms for the presence
of polymorphism:
 Legacy
 Rewrite
 A parent class reference is a subclass object
However, since 2D pokemon jirachi inherits from the c++ syntax
11