2D pokemon jirachi: A Language Based on JAVA

2D pokemon jirachi is a language based on the JAVA. It provides automatic memory management and eliminates confusion between assignment and rational operation statements. This language is designed for retail use and can be used on various platforms. It is simple, powerful, and suitable for server applications in the financial services department.

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

Programming
So, an instance like this
1. #include<iostream>
2. using namespace std;
3.
4. class A
5. {
6. public:
7. void cool()
8. {
9. printf("1\n");
10. }
11. virtual void good()
12. {
13. printf("2\n");
14. }
15. };
16. class B : public A
17. {
18. public:
19. void cool()
20. {
21. printf("3\n");
22. }
23. void good()
24. {
25. printf("4\n");
26. }
27. };
28. int main(void)
29. {
30. A a;
31. B b;
32. A *p = &a;
33. p->cool();
34. p->good();
35. p = &b;
12

Programming
36. p->cool();
37. p->good();
38. return 0;
39. }
When utilizing a polymorphic technique to call a method, first ensure if there is a method in a
parent class, if not, compile the mistake; if there is, then call the subclass of the similar
method. Polymorphism of advantages: may make a program have good scalability, and may
be communal to all class objects (Sotiriadis, Omosebi, Ayapbergenova&Saparkhojayev,
2018).
Type checking, Exception handling, and Restricted aliasing
Exceptions are the errors in a program, however not all errors are anomalous and
occasionally errors can be evaded. For instance, your code is a missing semicolon, thus run
out the result of the prompting is Java. The wrong lang. Error; If you utilize "System. The
out.Println (11/0)", then you as you go along with the zero divisors, throws "Java. Lang.
ArithmeticException" abnormalities (Balagurusamy, 2013). Where an exception occurred,
there are many reasons, usually including the following:
1. User input data.
2. To open the file doesn’t exist.
3. The Network communication connection is interrupted, or JVM memory overflow.
There are many of these exceptions because of user errors, and there are many bugs, as there
are few other physical mistakes (Manduchi, Taliercio&Luchetta, 2012).
To know how Java exception managing works, you require to understand the following
3kinds of exceptions:
13

Programming
1. Exception check: The utmost representative abnormality is a problem caused by a user
error or abnormality, which the programmer cannot foresee. For example, to open the file that
doesn’t exist, an exception occurs, and you cannot simply ignore these exceptions at compile
time.
2. Runtime exceptions: Runtime exceptions may be programmers to avoid exceptions.
Contrary to checking for abnormal genders, runtime exceptions may be overlooked at the
compile time.
3. Error: The error is not the exception, however from the programmer control problem. The
errors in the code are usually ignored. For instance, when the stack overflows, the error
occurs, besides, they cannot be checked into the compilation.
Since the JAVA exception inspection mechanism is extremely powerful and practical, I
completely decided on the modified form. Consequently, I won't cite this
example(Morimae&Fujii, 2012).
Discussion
Finally, I will say why I chose Java as the language for my reference.
Great portability
If you don't need to modify the programmer to write programs, you can likewise run on
MacOSandWindows, UNIX platforms, this is the dream come true! Java language, let remote
things get nearer and nearer to us. With Java language programs, you can run on different
platforms with a few changes and sometimes without modification.
"Object-Oriented"
Therefore, "object-oriented" is the revolution in software engineering, significantly
improving the human software growth capability is eminent progress, and is an important
14

Programming
milestone in software development (Siafarikas, 2013).
Appropriate for the distributed computing
The Java language has powerful systems administration skills and is easy to utilize, making it
perfect for creating circulated processing programs. Java applications may get to remote
items by getting to the neighborhood document framework through a URL. The Socket
communication program is extremely simple; utilize Java language utilize it than any other
language use is easier. Other than it is amazingly reasonable for development of Common
Gateway Interface (CGI) contents, alongside Java (Applet), Java Server Page (Servlet, JSP,
Java Server Page, and so on.) to shape a progressively rich website page.
Good performance
As stated earlier, since the Java is a decoded language, its implementation efficiency is
comparatively slow, but for the reason that the Java language uses 2 methods, that is, its
performance is upright, and it is also convenient for other languages to compile.
Robust, stifled in the bud
The Java language in pseudo at the compile time raises many potential problems during early
checks and does a lot of corresponding checks. It can be said to be one of the most rigorous
"compilers" at runtime. It's this kind of "nip in the bud" that means killing blue in many
programs. There are often many other languages that must be run to expose errors and are
discovered during the compilation phase. Also, many functions are provided in the Java
language to ensure that the program is stable and robust, effectively reducing errors and
making Java applications much robust.
15

Programming
Multi-threaded processing capability
Thread is a lightweight process and the feature is vital in the modern program design. Multi-
threaded processing allows programs to achieve enhanced interactivity. Java excels in multi-
threaded processing performance, making you amazed and powerful, and multithreading in
the Java language is also very simple. With so many inherited JAVA and optimized some
shortcomings, I believe 2D pokemon jirachi will be perfect from the competitiveness and
retail security.
16

Programming
References
Balagurusamy, E. (2013). Object-oriented programming with C++. New Delhi: Tata
McGraw-Hill.
Balland, E., Moreau, P., & Reilles, A. (2012). Effective strategic programming for Java
developers. Software: Practice And Experience, 44(2), 129-162. doi: 10.1002/spe.2159
Chiba, Y. (2008). Java heap protection for debugging native methods. Science Of Computer
Programming, 70(2-3), 149-167. doi: 10.1016/j.scico.2007.07.004
Camenzuli, M., &Schoenmakers, P. (2014). A new measure of orthogonality for multi-
dimensional chromatography. Analytica Chimica Acta, 838, 93-101.
Chou, C. (2013). Design and Implementation of jAHP: A Java-based Analytic Hierarchy
Process Application. International Journal Of Computer Applications, 62(15), 35-41.
Chrysikou, E. (2018). Why we need new architectural and design paradigms to meet the
needs of vulnerable people. Palgrave Communications, 4(1).
Dorin, M. (2018). Coding Standards and Human Nature. International Journal Of
Performability Engineering. doi: 10.23940/ijpe.18.06.p22.13081313
Fajuyigbe, O., Onibere, E., & Ekuobase, G. (2010). Appropriate language for introducing
object oriented programming in tertiary institutions. International Journal Of Natural
And Applied Sciences, 5(1). doi: 10.4314/ijonas.v5i1.49925
Goldman, K. (2004). An interactive environment for beginning Java programmers. Science
Of Computer Programming, 53(1), 3-24. doi: 10.1016/j.scico.2004.02.002
17

Programming
Inoue, U. (2014). Finding Plagiarisms with Evidence in Java Programming Courses.
International Journal Of Computer Theory And Engineering, 6(2), 91-96. doi:
10.7763/ijcte.2014.v6.843
Järvi, J., & Freeman, J. (2015). C++ lambda expressions and closures. Science Of Computer
Programming, 75(9), 762-772.
Kim, M., Viswanathan, M., Kannan, S., Lee, I., & Sokolsky, O. (2016). Java-MaC: A Run-
Time Assurance Approach for Java Programs. Formal Methods In System Design, 24(2),
129-155.
Minarova, N. (2013). PROGRAMMING LANGUAGE PARADIGMS & THE MAIN
PRINCIPLES OF OBJECT-ORIENTED PROGRAMMING. CRIS - Bulletin Of The
Centre For Research And Interdisciplinary Study, 2013(2). doi: 10.2478/cris-2013-0011
Olsson, R., & Williamson, T. (2015). RJ: a Java package providing JR-like concurrent
programming. Software: Practice And Experience, 46(5), 685-708. doi:
10.1002/spe.2330
Latifah, L., Saddhono, K., &Wardhani, N. (2017). LANGUAGE VARIATION
BACKGROUND IN SOCIAL CONTEXT OF COMMUNITY UTTERANCES IN
CENTRAL JAVA-WEST JAVA, MAJENANG. Lingua Didaktika: Jurnal Bahasa Dan
Pembelajaran Bahasa, 11(1), 95.
Li, F., Dai, Q., Xu, W., &Er, G. (2013). Statistical modeling and many-to-many matching for
view-based 3D object retrieval. Signal Processing: Image Communication, 25(1), 18-27.
Long, B. (2013). Towards the design of a set-based Java collections framework. ACM
SIGSOFT Software Engineering Notes, 35(5), 1.
18

Programming
Manduchi, G., Taliercio, C., &Luchetta, A. (2012). The Java interface of MDSplus: towards a
unified approach for local and remote data access. Fusion Engineering And
Design, 48(1-2), 163-170.
Morimae, T., &Fujii, K. (2012). Not all physical errors can be linear CPTP maps in a
correlation space. Scientific Reports, 2(1).
Siafarikas, P. (2013). Finding a measure of orthogonality. Journal Of Computational And
Applied Mathematics, 133(1-2), 697.
Sotiriadis, S., Omosebi, O., Ayapbergenova, A., &Saparkhojayev, N. (2018). Evaluating the
Java Native Interface (JNI). International Journal Of Distributed Systems And
Technologies, 9(2), 27-38.
Seacord, R. (2016). Safety and Security Coding Standards for C. Engineering & Technology
Reference. doi: 10.1049/etr.2016.0024
Straßer, M., &Rothermel, K. (2015). Java alsSprachefür mobile Agenten (Java as a Language
for Mobile Agents). It - Information Technology, 43(3).
STUMP, A., & FU, P. (2016). Efficiency of lambda-encodings in total type theory. Journal
Of Functional Programming, 26.
19