Executive Summary
With the change of the requirement in the technical field, languages are evolving continuously. With more enhancements in the language, their effectiveness incises gradually. In the current scenario, there are several high-level languages like Java, C++, Python which provides efficient coding techniques along with reliability. Due to this reason these languages are used frequently for the designing of secure banking applications. Though these languages are efficient, but not capable to handle every requirement of the baking applications entirely using a single language. Due to this reason, multiple programming languages ware used to design a complete banking system. Due to the use of multiple languages, interfacing overhead comes in existence. It would be a novel concept, if we can design a new language by deriving the features of the contemporary languages, to addresses every requirement of the banking software. In this essay, we have proposed features of a new language which will address all the issues of the secure banking software design.
Table of Contents
Basic Programming Architecture 5
Summary of Memory Management 6
Readability, Writability and Reliability 13
Introduction
In the past, the banking sectors were using different languages for programming of the digital platform such as C#, Python, C++ and many more. These programming languages have their strength, properties, and field of operation. Striking features of these language properties make them the core language for programming in the digital banking sector. The basic programming languages like C# or C++ are usually utilized for machine-level designing. On the other hand, COBOL is utilized for the development of mainframes. It can be analyzed that every programming language has a contribution at different stages of system development and how these dialects help complete the final stage of the new system. Of all these programming dialects, the Java programming language is one of the popular languages which uses for a wide spared of application in the baking field. Due to this reason many software engineers like to build financial software using java. Though Java has its limitations and that is way still we use other languages to support Java. It would be a novel concept, if we can design a new language by deriving the features of the contemporary languages, to addresses every requirement of the banking software. In this essay, we have proposed features of a new language which will address all the issues of the secure banking software design.
In the current scenario, the Financial and Banking sector is a huge domain. There are several kinds of application are to work together to support the banking industry. Different sub-domains of the banking sector, like a business, finance, and customer relations, online baking have their unique requirement. All these domains, one thing is common and that is the secure and accurate processing of the bulk amount of the user data. The newly designed programming language must provide high-level assurance of the reliability, security and high volume of data handling. For the proper design of the language in the future, we have maintained modularity in the proposal. The specification of the target language has been given based on the following parameters:
- Simplicity,
- Orthogonality,
- Data types,
- Syntax design,
- Support for abstraction,
- Expressivity,
- Type checking
- Exception handling, and
- Restricted aliasing.
Further organization of this report is as follows: Second chapter of this report language purpose, language translation scheme and memory management. Chapter three designated for the language features. Discussion of the readability, writability, and reliability is given in the last chapter of this document.
Basic Programming Architecture
The target programming language will support the entire banking industry. So the language must ensure platform independency so that any type of hardware system can take benefit of the new programming language. Apart from this, the language must also support GUI design for the front-end and mathematical model implementation for the back-end system. Support for every RDBMS system (for efficient data storing), Network connectivity feature (for distributive design), Encryption support (for data confidentiality), exception handling (for robustness) is also required to support the banking application. In the following part of this document, we have proposed the technique to achieve platform independency in terms of language translation technique and execution platform. We have also given focus on the memory management facilities for the proposed banking language.
Language Translation
The proposed programming language must use a combination of Compilation and Interpretation for the language-translation. Both of these two language translation techniques have their strength and weakness. In one side Interpreter performs translation line by line which is efficient to achieve platform independency as target code generation did just in time manner based on the underlying hardware. Though the processes are slow as compare to the compiler. In case of compilation, source code to target code generation done at a time for the entire source code. In these processes, we can identify all the errors if they exist in the source code but the target code works only in the target hardware.
The proposed programming language suppose to use Compiler to generate a middle-level language. This process will help to eradicate every possible error present in the source code language. So this process will generate error-free reliable codes for the banking application. Now based on the hardware support, a runtime environment will use an interpreter to execute the code in specific hardware. Using this collaborative process, the proposed language will achieve platform independence. Moreover, it is also recommended to implement a cache to store frequently used middle-level instruction and its translated instruction. This code will reduce the translation overhead for the repetitive instructions generated due to looping and branching.
The proposed language translation shares many similarities with the Java programming platform. But still, there exists an advantage of the proposed scheme over Java’s architecture. In java, Bytecode runs on the JRE and all instruction gets executed through the interfaces of the Host OS and that is why codes run comparatively slow. In the proposed scheme, for every Hardware setup, there will be a unique Interpreter which will generate machine code directly for that hardware. So these processes will limit the dependency of the Host OS for the code execution.
Memory management
Efficient memory management is very essential for the good performance and reliability of the programming language. Programming language like C, C++ provide a higher degree of liberty to the programmer, for memory management. Though the liberty of memory management to the programmer cases code vulnerability when programmers make improper use of the memory resource in the code. That is way often runtime errors like segmentation fault happen in the C, C++ code. Due to this reason many modern languages like Java, Python makes memory management as the internal task of the language. According to this proposal memory management will do internally.
In the proposed Programming language, the memory will be segmented in two main parts such as Stack Memory and Heap Memory. Stack segment will store local variables and object references. On the other hand, heap memory will be used to store the object. This programming language will not allow the programmer to create an object in the stack space. Stack space is always limited for any language. Allowing the programmer to allocate memory crunching objects (often required in the baking application) in stack space may cause the reason for the runtime error like stack-overflow.
The programmer will use some operator (suppose alloc in the proposed language) to create an object in the target language. With the operator, the programmer will specify the constrictor name and parameter to initialize the code. As a consequence, the runtime of the code will allocate the object in the heap memory and it will also initialize the allocated memory segment. Programming code will access this memory only using the hash value of the memory address. This processes will restrict the direct access of the heap memory. We also need a memory deallocator, which will keep track of the unreferred objects. It will destroy the object there will be no reference of the object.
The proposed memory management scheme will hide the complexity of memory management from the programmer. The programmer will only request for the memory allocation and after use programmer will nullify the reference of the allocated memory. Internal language facility will manage the entire allocation and deallocation of the memory.
Summary of Memory Management
- In the Proposed Programming, there are two memories factors as Heap and Stack memory.
- The Stack is used for the variables that are used or declared locally in the program.
- The Heap is used for the variables that are declared and used globally in the program.
- The variable declaration for the Heap is done by using a new keyword in the syntax.
Language Specifications
The proposed programming will follow the concept of OOPs (Object-Oriented Paradigm). The target language will work in the banking domain so it should deal with multiple real-world entities. Using the OOP features, it will able to model complex entities in a very simple manner. This can be achieved by defining class types in the proposed language. The class feature will allow creating real-world entities based on their attributes and functionality. Apart from this, using OOP concept, the programmer will able to draw relationships among different types. The OOP properties which suppose to achieve by this proposed programming language are listed in the following section.
Encapsulation
Encapsulation is one of the four basic concepts of the object-oriented paradigm. The other three are inheritance, polymorphism, and abstraction. It is a mechanism for wrapping data (variables) and code that works on data (methods) together. This creates a single unit of variable and data that can be used in the program. In encapsulation, the variables of one class will be hidden from other classes and can only be accessed using the methods of the current class. That is why it is also known as data hiding.
Inheritance
Inheritance is very useful features to model relationship among types in the OOP paradigm. Using this feature, one class inherits the features or behavior of another class. This divides the classes into two categories such as parent class and child class. The child class inherits the properties of the parent class in the same program.
Polymorphism
The polymorphism is another property that OOP based programming. With the help of this feature, the developer can provide a different context to the variables with the same name according to the situation. For example, the word withdraw is commonly used in the banking sector and it is used for both current and savings account. The polymorphism features differentiate the word according to the situation such as withdraw option for current account and saving account separately.
Message Passing
The message passing is used for communication purpose. Using this technique multiple types work together to achieve some collaborative objective. In the field of baking application, message passing is very important as every computation in the baking field depends on multiple entities. The target language will achieve message passing techniques using the following strategies.
- Returning the value from a function,
- Methods invocation
- Throwing exceptions
- Parameter passing.
Code Orthogonality
The code orthogonality is used to bring an effect on the whole system by modifying the code segment. The factors are also known as modularity parameter. To make the target language highly orthogonal, it will enforce the programmer to write code with low coupling. For this enforcement, it will not allow procedural code with the proposed language. Use of class-based programming always helps to reduce coupling. In the Class-based programming, one entity accesses other entities based only on public methods. In such programming architecture, one class can modify its internal coding/ implementation without affecting the behavior of other classes.
Example
Consider a situation of the authentication verification, where two classes working together. One class provides the GUI interface and other one check the authentication based on the user and the hashed password value. During authentication checking, GUI invokes a method on authentication verifier function and supplies userID, hashed password value. As a return value authenticator class returns a boolean (true/ false) value. In this design, we can modify two classes independently. This is possible because the level of coupling is low in the design.
Data Types
There will be two kinds of data types in proposed programming such as primitive data type and another is non-primitive data type. The primitive data type is like the common data type which is also used in the other programming languages. This data will not depend on any other types. Probable list of the primitive data types, their size, probable value range are given in the following table.
| Primitive type | Memory | Details |
| Byte | 1- Byte | Whole numbers (Range -128 to 127) |
| Short | 2- Byte | Whole numbers(Range -32768 to 32767) |
| Int | 4- Byte | Whole numbers(Range -21487483648 to 2147483647) |
| Long | 8- Byte | Whole numbers(Range -9223372036854775808 to 9223372036854775807) |
| Float | 4- Byte | Fractional data(Range 3.40282347E+38F) |
| Double | 8- Byte | Fractional data(Range 1.7976931348623157E+308) |
| Boolean | 1- Bit | Boolean values(True or False) |
| char | 2- Byte | A single UTF character |
On the other hand, the non-primitive data type is about the classes interfaces by which the programmer will define their types. All these data-types will content some internal variables (primitive or non-primitive). With the inclusion of one type within another, the programmer will able to design a very complicated object structure. This feature is very important in the field of banking software.
Syntax Design
The syntax which will be used for the proposed programming will share features with other common programming languages like C, C++, and C#. The adaptation of the block-structure coding will help to give a better understanding of the existing programmers who are working with C++ or in Java. In the syntax, the block structure starts with ‘{’ and ends with ‘}’. The developers need to be careful with the case of the keywords while writing the syntax because the target language will be a case sensitive one. The case-sensitivity will help to preserve consistency in the coding style. Probable structure of the code in the target domain will look like as follows.
| For IF condition: If (condition) { //operation } else { //operation; }
| For Switch Condition: Switch (variable) { Case1: //operations; break; … Default: //operations; break; } | For FOR Condition: For (int a= 0; a<10, a++) { //operations } |
| For While Condition: While (condition) { //operations } | For Class Condition: Class sample { Private int k=0; Public sample () { k= 100; } Public void testing() { //operations } } |
Coding conventions
- The first letter of class name should be capital
- The first letter of method name and attributes should be small.
- Camel case must be used to write the multiword name.
Support of Abstraction
The target programming language will also support the abstraction as it will be based on the object-oriented paradigm. Details of the abstraction feature are already discussed during the explanation of the OOP support.
Expressivity
The expressivity is about the readability of the code of programming language that whether the user or computer can read and understand the code. The target programming language will have moderate expressiveness. As the language will derive the coding structure from the C, C++, and Java, so it will be very easy for the experienced Java or C++ programmer to learn the syntax. Still, it is expected that armature programmer will face problem to understand the language structure. In the current scenario, there are several high-level programming languages like Python, Grove which provides more comprehendible coding structures. This language provides better expressivity but still, C like structure is adopted as experienced programmers prefer C like programming structure.
Type Checking
The proposed language will be strictly typed. The proposed language will work in the field of banking, so it is important to assure type-safety for the language. During the declaration of the variable, it will be necessary to declare the type of the variable; the compiler will check the type safety of the variable during its lifetime. This process is necessary to ensure that the developer is not able to change the type of variable declared in the program. In proposed language, the supper-type variable will allow containing a reference of its derived type, but this does not apply to the inverse scenario.
Exception Handling
Any reliable programming language must provide the scope to handle unexpected scenario during runtime and this is done by the exception handling. The proposed language will work in the banking domain, so exception handling will be a must needed facility. This technique will be used to handle inconsistent transaction scenarios. While handling the exception, the programmer will identify the segment of code where an exception may arise and the programmer must mark that segment using a try block. Using catch and finally block programmer will deal with the exception. Details of each block, their functionalities, and the probable coding structure are shown in the following part.
| Keyword | Description |
| Try | It indicates the specified block where the exception needs to be placed. It must be followed by catch or finally keyword. |
| Catch | This helps in handling the exceptions. Try keyword must be used before the use of Catch keyword. |
| Finally | The keyword finally is used to execute only the important code of the program. This executes the program either the exception is there or not. |
| Throw | This keyword is used to throw an exception. |
Example code
/* my exception is a checked exception for test exception function */
Public void test exception (<type> param) throws MyException
{
Try
{
//instructions
}
Catch (some exception use)
{
Throw new MyException();
}
Finally
{
//close resources
}
}
Aliasing Technique
Aliasing is a technique of providing multiple names for the same entity. In programming, language aliasing is used to create multiple handles for the same object so that concurrent operation can be done on the object. In the proposed language there will be aliasing support for the class-based objects. For the primitive data-types, there will be no scope of aliasing. While assigning one primitive element on another it will create an identical copy of the previous type. This phenomenon is shown in the following is demonstrated using the following images.
For aliasing class-based objects, we have to copy object-reference variable to another object reference variable of a compatible type. According to the consideration of the memory management scheme, the reference variable will hold the hash value of the object location, so the assignment of the reference variable will only create an alias of the existing object.
To create an independent replica of the existing object, the programmer must define a constructor which will take the reference object as a reference and it will generate a new object based on the reference object.
Readability, Writability, and Reliability
Readability
The readability of a programming language depends largely on the reader’s previous experience with it or with a similar language. The target language will share coding features with C, C++, and Java, so the code will be very easy to understand for the experienced programmers. Using brackets ({}) to define blocks in the program can significantly improve the organization of most complex programs if used with care. The names of compound statements (if, while, etc.) are obvious, which makes it easier to explain the actions performed by a simple program in English. Finally, since language is case-sensitive, variable names must be in the same case, and all reserved keywords and keywords must be lowercase. This prevents reading by verification to make sure that a variable or class has been written correctly each time: the compiler will detect any spelling errors or incorrect capitalization in the program. Memorization and recognition in the program take more time but allows easier initialization of the length of the array when creating an instance. However, it can be stated that the readability of the C++/Java programming is moderate, so the target language will have the same level of readability.
Writability
Writability parameter of the program defines how easily we can define complicated instruction to the language translator. Writability of the target programming language will be very high as it will support OOP features and inherit coding techniques of C++ and Java. OOP designing paradigm will enable a programmer to define a complicated relationship using very few lines of code. Property of inheritance will incise code reusability and Writability both. Apart from the OOP features, different short-hand notation line multiple variable declarations in a single line, hybrid operator ++, +=,-=, etc also help to improve Writability of the code.
Reliability
Reliability is the last but most important point of this discussion. The target language will work on the banking domain, so it is very important to achieve reliability in the programming structure. To achieve reliability, this proposed language has made several consideration. List of reliability majors and their implication are given in the following section of the document.
Dedicated Memory management: Dedicated memory management scheme, will shift the memory management burden from the programmer to programming infrastructure. This will reduce the chance of program, failure due to pore memory management.
Exception handling: exception handling will reduce the chance of program failure during any unexpected user input to the system. Exception module will take corrective majors, and take the system in the safe state.
Encryption support: Inbuilt support of the encryption module in the program, help the programmer to design the secure application without taking help of the third-party application.
Reliable network communication support: Most of the baking application works in a distributed architecture that is why the language must provide library support to create secure connections like SSL.
Conclusion
As a conclusive remark, we can say that this initial proposal document, surveys the existing languages using in the baking domain, find out their limitation limitations and proposes a new language which can resolve the existing implementation issues. Before the actual implementation of the language, we must perform mode details study on the proposed features of the futuristic language. While proposing the new language, we have tried to adopt striking features of the existing languages, to minimizes the risk of pore requirement analysis.
References
Higuera, T., Issarny, V., Banâtre, M., &Parain, F. (2004). Memory Management for Real-Time Java: An Efficient Solution using Hardware Support*. Real-Time Systems, 26(1), 63-87. doi: 10.1023/b:time.0000009306.22263.59
Flynn-Hummel, S. (1999). High-Performance Java Compilation and Runtime Issues. Scientific Programming, 7(2), 85-85. doi: 10.1155/1999/824062
Gong, S. (2014). Research on Java Development Kit Based on Complex Networks. Applied Mechanics And Materials, 543-547, 2953-2956. doi: 10.4028/www.scientific.net/amm.543-547.2953