Introduction and explanation of language purpose
It is rare that a programming language among the several programming languages that have emerged since the development of Plankalkul in 1940 is explicitly developed for the problem domain of banking. COBOL (Common Business Oriented Language) was used in writing business software up until 1980s when it was replaced by C and C++ programming languages. These included but not exclusive of banking applications, payroll as well as accounting among others. COBOL language has proven to be an outstanding language for manipulating the operational data that banks depend on for handling transactions; nearly all the economic algorithms were written in COBOL (McCracken, 1976). With reference to COBOL, I have come up with a robust programming language that will equally facilitate programmers with the use of familiar language, enhance simplicity, readability, reliability and specific to the problem domain of banking.
The name of the language is My Programming Language for Banking, abbreviated as MyPLB. This particular name is chosen for the reason that the language will be specific to banking domain thus My Programming Language for Banking MyPLB.
Like COBOL, MyPLB will be specifically for finance, human resources as well as other computer program business within banking domain. As a result, the language will involve financial, accounting as well as statistical calculation to solve the problems in banking domain. The language will also be included in a simulation involving numbers. As a result, MyPLB will be able to do the following:
1.Capable of performing calculations engaged in banking.
2.Will support currency; MyPLB will support very many processors concurrently and process a considerable amount of data at the same time.
3.It will have the capacity to accommodate a large number of numbers.
4.Perform data analysis and present data well with the help of charts and graphics
5.Will process a massive amount of data.
6.Will model some real-world problems through custom data types
For a system to perform the tasks mentioned above, it must have well-defined algorithms. The hardware, including computers that will be used for programming MyPLB, must have large RAM and be of high speed so that the programs can get computed as fast as possible. MyPLB is created such that it will utilize the object-oriented programming methods just like some other languages that have been developed before. As a result, the MyPLB language has the following object-oriented programming characteristics:
- Polymorphism:refers to the ability to exist in various forms. This will enable the operations performed by MyPLB to exhibit different behaviors at different instances depending on the data that will be used during the process.
- Inheritance:the capability of a class to get derived from a base class with the features of the base class as well as some of its own thus increasing the reusability of the programs, hence adding more features to the already existing program.
- Abstract:the ability to present data conceptually without delay.
- Encapsulation:the ability to capture data and to secure it from the outside interface.
The codes will get translated into machine language efficiently when written well, meaning that it will perform the financial operations including financial calculations involved in banking. The programming language is developed in search a way that it supports various artificial intelligence features; thus it can be used in forecasting future trends. For that reason, it will aid in performing better analysis and enable banks to plan for the future if the future seems unfavorable for the organization.
Choice and justification of interpretations/compilation methods used
Choosing the object-oriented methodology is of great benefit since it will enable the reusability of the programs and support various features that are object-oriented (Engelson, 2000). The programming language with such characteristics are robust, and this is one of the features that are checked when selecting a programming language to be used within the banking domain. The use of other methods in place of object-oriented would lead to difficulty in implementing various functions including the speed of computation and concurrency of the program.
The MyPLB will be developed so that it supports a significant amount of data types that are essential in financial as well as statistical operation of the program. For this reason, it will perform various calculations which are associated with several types of data types, and it is defined in a manner that it holds both long and short data types so that the numbers are computed efficiently when calculations which need these numbers are done.
In addition to the features mentioned above, I saw it was essential to include graphics features that would aid in data representation more understandably. The language features should support graphics so that its users can be able to interpret data in a better manner during data presentation. The language will also allow its programmers to design their graphs to help them to present data successfully.
MyPLB is developed to support a vast amount of data due to the fact that in the banking domain, various calculations are done, and data will also need to be stored. Therefore, a significant amount of memory is required to perform the activities. Additionally, when designing applications for banking, the interface will be needed to be user-friendly, and that is the reason why I proposed the graphical user interface that will guide the users in determining which task to do.
Generally, the object-oriented approach is applied in this programming language to ensure that the compiler that is developed will convert instructions in a faster way from high level to low-level instructions. Developing the programming language in a low-level instruction would be better for the compiler to take the shortest time. But for the sake of making the language to be easy to understand by its users, a faster compiler that will facilitate faster translation to a lower programming level will be needed.
During the implementation process, a hybrid model, including legion (both fine-grained imperative and coarse-grained functional) will be included. This model consists of simple tasks with contra variant arguments which will get passed in and out by the value. By this, the implementation of tasks will be made imperative or functional hence enhancing the flexibility of this programming language in a manner that it can operate in an object-oriented way or functional and imperative way (Engelson, 2000). As a result, the language will offer a favorable environment for a wide range of its users who consider using various programming methodologies.
Memory management and scoping features of MyPLB
This is a very crucial aspect which needs to be put into consideration during the development of a programming language. Various techniques can be deployed to manage memory including real-time application or applying the traditional methods of programming. The MyPLB, however, will have automatic garbage collection features, see figure 1. This will relieve its users from the burden of managing memory of MyPLB applications now and then. The framework that will be used in implementing this is the customizable memory management (Flood, Detlefs, Shavit, & Zhang, 2001). This framework depends on the primary collector which exploit Bartlett’s copying garbage collector evolution.
Figure 1: Memory management property
The proposed method for the development of the memory management features of the programming language is the design of algorithms that will implement garbage collection to release memory as demonstrated in figure 2. Since the language being developed is to be used within banking domain, the algorithms should be concurrent, real-time, and officious and must be able to run in commercial uniprocessors and multiprocessors as well as systems with shared memory (Flood et al. 2001). These algorithms can also be in a position to use virtual memory hardware so that the collectors and mutator threads can get synchronized easily.
Figure 2: memory life circle
As far as scoping is concerned, this programming language will implement global scoping and local scoping (even numerous existing programming languages use this rule). The rule will determine how to define the free variables which are found within the body of the scope and are not defined.
Lexical scoping (also known as static scoping) is another scoping method that will be included in the language design. Various programming languages also use this convention. It will be used in MyPLB program as well to set the scope of variables so that it may only be invoked from within the block of codes where it is compiled. If a variable is not found in a given scope of this particular scoping method, the enclosed scope is searched repeatedly until the outermost scope is gotten.
The specifications for significant language features
The specifications for language features refer to the documentation artifacts that define a programming language so that its users can agree on the programs on the language mean. The specifications are always formal and detailed, and they are primarily used by programmers with the implementers referring to them as ambiguity. MyPLB language will as well have specifications for its significant features stated and illustrated in the following manner.
A functional programming language should be easy to learn and use, it should also be able to perform all its operations with ease including defining/declaring variables and working with control structure as well as integration. The language should be created in a manner that its novice implementers can use a range of objects which are required.
To meet the aforementioned needs of a programming language with “simplicity” feature, the language designer must incorporate the graphical user interface to give the novice implementers easy time while working with the language. Various objects including charts, text boxes, checkboxes and labels, list boxes among others should be developed so that users can drag and drop them and insert a program to perform a given task on the objects. Programming is made simple by putting much concentration on the user interface; the users will, first of all, get impressed by the user interface after which they may consider other features of the program.
The syntax of codes which are to be used is another important feature which should be put into consideration while designing a programming language. The best syntax that will be utilized in the development phase for MyPLB will be in English. The main objective COBOL language was to be natural, where being natural meant “English like”, which was meant to increase the readability of the programs (McCracken, 1976). Therefore, the syntax for MyPLB should be designed in such a way that it will be very far from the assembly language, meaning that it will deal with more of binary language. By this, the compiler will be in a position to translate the English-like language to machine language easily. Such syntax will make it easy for implementers to apply the program since the codes can be easily read and understood.
This is one of the critical aspects that should be put into consideration when developing a programming language. As a result, it will be implemented in the MyPLB development for the incorporated designs which are complex to be compact; the orthogonality property makes languages which are complex to be compact. By utilizing this property, MyPLB operations will not develop side effects during the implementation of the orthogonal design. I will combine the relatively small set of primitive constructs in multiple numbers to build the data structure and control the codes.
The orthogonality concept will also get utilized in MyPLB as a way of describing modular and maintainable application development. By this, we will be sure that the design aspect for one side does not affect the design aspect for another side. This feature is also depicted in Java programming language which is famously known for developing banking applications.
The data types in MyPLB programming language will be composed of integers, strings, floats, doubles, char, and Boolean. These data types will be used in defining the operations to be used in creating, transforming and using variables in a given program.
As the problem with COBOL is that it has very lengthy codding, MyPLB however will support short codes which are simple and easy to understand. Basing on the fact that MyPLB will be based on a lot of financial operations involving accounting and data analysis, the integer data types will be divided into long and short data types. This is to ensure that during the implementation of the language, its implementers will be needed to key in their preferred data types and define them in programming activity.
As typical like many programming languages, MyPLB will define keywords before syntax are done. COBOL language has over three hundred key words, some of which have pluralized or simple alternative spellings. These key words will provide for more English like statements increasing the readability of the language. Variables in the program, however, will not be defined using the keywords to avoid conflicts with the defined keywords. These keywords will be essential in defining syntax. The syntax to be used in the MyPLB will either positively or negatively affect the reliability of the language. However, specific variables will be made so that they can be declared and accessed everywhere within the program.
Besides, exception handling will also get implemented in the MyPLB program; this will help in catching the error before the programs are executed thus making debugging easy. This will be made in such a way that if a given data is out of range, an exception is thrown, and the code will not be executed but provide feedback to the user thus preventing many unnecessary bugs which might occur during the programming process.
Case statements will also be featured in the programming language for syntax definition to help in handling various programming scenario. It will be defined according to financial and statistical problems which are encountered by programmers. As such they will operate like conditional statements in one way or another
Support for abstraction
The MyPLB will be designed to support its users in creating abstractions. The language will, therefore, hide its implantation details from its users; it will only show the functionality of the codes used. The program will have this feature so that the users of MyPLB based application will not be in a position to tell how various functionalities of the codes are implemented to function but instead the users will only know the functionality of the application. For instance, when a person withdraws funds using an application designed by MyPLB, the individual will only receive a confirmation message regarding the transaction done but will not be able to know the background process involved during the transaction process.
In the context of programming language, expressivity refers to the breadth of ideas that can be presented through the language. The MyPLB language design will have declarative language features. As a result, it will use some primitive constructions. For example, FOR instructions can be used together with WHILE instruction. However, some intuition may get lost. The expressivity will be implemented by reusing the programs since the language will support object-oriented programming language.
The MyPLB will have some procedures which will be applied in supporting the expressivity of the codes. According to my experience with various programming languages, frequently, logic programming is more expressive compared to functional programming. For this reason, the language will include some logic which will get incorporated with various prolog programming functionality to enhance the expressivity of the language. The implementation of this will necessarily follow the actual implementation of the object-oriented method designed in a manner that it takes more time during the implementation process.
As far as the programming language is concerned, type checking is a set of rules that assign a property known as “type” to different programming constructs including variables, and expressions among others. Type checking occurs typically during compile time or even run time. It can be typed either statistically or dynamically depending on the specific language used. MyPLB will utilize the dynamic type checking through a type system.
The utilization of this type checking will reduce type errors to some extent (Coquand, 1996). The type errors refer to erroneous behaviors experienced by programs where certain operations which are not meant to occur feature in data types. The operations may be those that are performed in an integer with an intention that they are floats. The dynamic type checking will be the most preferable for MyPLB language because it leads to less optimized codes when compared to the top static type. The dynamic type checking will be supplemented with the unit checking.
To the point of fact, various statically designed programming languages usually get incorporated on executing them while most powerful languages are translated when they are implemented. However, for effect, this cannot be generally expected. When it is said that a given language is static or dynamic, there is an allusion to dialect all in all. As an example, notwithstanding the adaptation of java that can be utilized, the program will be dependably statically written which is entirely different from as whether the language is aggregated or deciphered, basing on the fact that in that announcement we are alluding into a particular language execution. However, in the real sense, any language can get incorporated or deciphered. The successful execution for Java is by arranging to bytecode, and JVM translates the bytecodes. Nevertheless, there are various functions of Java that get the Java codes deciphered as seems to be or order individually to machine codes.
Exception handling is construed as the process of responding to an occurrence during programming that often alters the flow of program execution. It will be very essential in MyPLB language where calculations will be required. The exception handling concept will be used in the computer dialect to catch the invalid inputs from users and output a message regarding the invalid input in MyPLB language. The idea will be used in developing MyPLB language so that any calculation made by MyPLB based application will be valid thus ensuring accuracy to its users.
If it happens that a blunder occurs inside a specific technique, a question is made by the strategy and handed to the runtime framework. The problem (known as the exemption protest), will have the data concerning the mistake that happened, its sort as well as the condition under which it occurred. Making a unique case protest and giving the protest to the runtime framework is referred to as tossing exemption. After a given technique tosses a particular case, the runtime framework will endeavor to discover something to overcome it. The preparation of the conceivable thing to deal with the specific situation is the requested rundown of the strategy that had been invoked to get to the technique where the mistake occurred.
In computer programming, aliasing means a situation where one memory allocation can be accessed using various names. As a result, modifying data through one name indirectly changes the values which are related to the aliased names which may not be expected by programmers, aliasing offers substantial imperatives in a program execution arrange. When it happens that the two constitute gets to pseudonym happens in the content of a program in succession, they should occur in group in a machine program. Requesting the gets to again will create a wrong program outcome and the same applies to a reader gets to as well as compose gets to.
The readability, writability, and reliability of MyPLB based on the language chosen characteristics
It is my confidence that with all the aspects mentioned above, the programming language developed will be reliable and meet the needs of its users in the banking domain as envisioned. The language will also be designed in a way that it will not crush easily and cause problems for its users. With all the features mentioned above including type checking, expressivity, exception handling among others, I can be sure that the language will be easily reliable as compared to other languages and will meet the demands for which it is designed.
Additionally, MyPLB language will be simple and easy to use since its syntax are based on the English language which can be read by all type of implementers including novice users. The simple syntax in the programming language improves the readability of the dialect as well as the writability of the codes. Lastly, the language programmers will incur less error due to the type check feature of the language.
Flood, C. H., Detlefs, D., Shavit, N., & Zhang, X. (2001, April). Parallel Garbage Collection for Shared Memory Multiprocessors. In Java Virtual Machine Research and Technology Symposium. Retrieved from: https://www.usenix.org/legacy/event/jvm01/full_papers/flood/flood.pdf [Accessed on August 23, 2018]
Coquand, T. (1996). An algorithm for type-checking dependent types. Science of Computer Programming, 26(1-3), 167-177.
Engelson, V. (2000). Tools for design, interactive simulation, and visualization of object-oriented models in scientific computing (Doctoral dissertation, Linköpings universitet). Retrieved from: https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.96.3408&rep=rep1&type=pdf [Accessed on August 23, 2018]
McCracken, D. D. (1976). A simplified guide to structured COBOL programming. John Wiley & Sons, Inc.