Commercia Programming Language: Features, Readability, and Reliability

This report provides a comprehensive analysis of Commercia, a newly proposed object-oriented programming language designed for e-commerce site development. The report begins with an executive summary and an introduction outlining the language's purpose and intended functionalities. It then delves into the selection and justification of interpretation methods, emphasizing the advantages of an interpreted language for debugging and memory usage, while acknowledging the speed drawbacks. The discussion extends to memory management, highlighting Commercia's garbage collection system and its handling of scoping features. Furthermore, the report presents the rationale and specifications for Commercia's key features, including simplicity, orthogonality, data types, syntax design, and support for abstraction, providing detailed explanations and examples for each. Finally, the report assesses the language's readability, writability, and reliability based on its evaluated characteristics, concluding with a summary of the language's strengths and weaknesses. The report is a comprehensive guide to understanding Commercia's design and suitability for e-commerce applications.

Running head: COMPARATIVE PROGRAMMING LANGUAGE
Comparative Programming Language
(Language for the problem domain of E-commerce)
Name of the student:
Name of the university:
Author Note

1COMPARATIVE PROGRAMMING LANGUAGE
Executive summary
In this report, a new programming language is chosen for developing e-commerce sites. It is named
Commercia. Here, a discussionis made behind choosing Commercial with the justifications. Next
various choice for interpretations methods that can be used for Commercia is evaluated. After that, a
demonstration is done regarding memory management. Then the different features of scoping are
analyzed. After that, an assessment is provided regarding the specification and rationale for the vital
features of Commercia. Lastly, a discussion is made here keeping the writability, readability and
reliability of the programming language. This is based on the various characteristics of Commercia
as evaluated.

2COMPARATIVE PROGRAMMING LANGUAGE
Table of Contents
1. Introduction and explanation of language purpose:...........................................................................3
1.1. Introduction to the present study:...............................................................................................3
1.2. Explanation of the purpose of the language:..............................................................................3
2. Choice and justification behind the interpretation methods to be used for Commercia:...................4
2.1. Understanding the choice of interpretation methods:.................................................................4
2.2. Justification of choice:................................................................................................................4
3. Evaluating the memory management along with scoping features of Commercia:..........................5
3.1. Discussion on memory management:.........................................................................................5
3.2. Analysing the scoping features:..................................................................................................6
4. Rationale and specification for the features of Commercia:.............................................................6
5. Readability, writability and reliability of Commercia:....................................................................13
5.1. Discussing the readability:........................................................................................................13
5.2. Analyzing writability:...............................................................................................................13
5.3. Reliability evaluation:...............................................................................................................14
6. Conclusion:......................................................................................................................................14
7. References:......................................................................................................................................16

3COMPARATIVE PROGRAMMING LANGUAGE
1. Introduction and explanation of language purpose:
1.1. Introduction to the present study:
In the current digital era and with the developments in web technologies, it is easy for
businesses to possess a website for them. As one plans to acquire an e-commerce site the initial
aspect to be considered is to choose a specific programming language for the project. The
ecommerce site is needed to be visually attractive and highly functional. It must be reminded that
every language encompasses its individual pros and cons. Thus selecting any effective coding
language relies highly on the requirements.
The following study deals with the discussion on the justification and choice of the
interpretation methods to be used in the programming language. Then, a discussion is made on
memory management along with the features of scoping. Next, the rationale and specification for
important features of the languages are discussed. After that various reliability, writability and
readability of the language based on its characters are evaluated.
1.2. Explanation of the purpose of the language:
The present programming language was chosen to be developed named Commercia. This
should be an object oriented language. Further, it must be a class base that is to be used to create
eCommerce sites. Besides, Commercia must also be equipped with various robust tools. This is to
make the developers turn into more productive. Commeria is estimated to be a largely versatile
language. This should be working efficiently over every kind of browsers. This must also be
powerful in terms of debugging. It is meant to be critical for the business over the Internet in the

4COMPARATIVE PROGRAMMING LANGUAGE
scenario of the real world. Apart from this, its integrated development environment must be making
the overall process of development quick, seamless and effective.
2. Choice and justification behind the interpretation methods to be used for
Commercia:
2.1. Understanding the choice of interpretation methods:
The syntaxes of Commercia must be highly influenced by Java and C++. However, the core
workings of Commercia must be nearer to the interpreted languages like Ruby and Python. Hence, it
should be closer to this dynamically typed. Hence, it is meant to be an interpreted language.
Commercia must have no step for compilation. Rather, an interpreter within the browser should be
reading on the codes of Comemrcia. It should be further interpreting every line and then make it
‘Run”.
2.2. Justification of choice:
First of all, it must be helpful for debugging. The interpreter methods of Commercia must be
making the debugging easy. This is because it can quickly check the source codes. Then, another
advantage of it is its memory. This must utilize lesser memory than its executable file. This is due to
the fewer lines of sources that are required to be in the memory, just at any instantaneous time. The
interpreters of Commercia must be executing codes under the virtual machine (Feo, 2016).
Moreover, it can be developed for dis-allowing the code coming directly from accessing the
computers. Hence, as the virtual machine gets crashed with the erroneous code, the host machine
must be running smoothly.
However, here the greatest disadvantage here is its speed. It must be reminded that the
interpreted code has been running slower than its compiled codes. Here, the reason is that the

5COMPARATIVE PROGRAMMING LANGUAGE
interpreter has required to assess and convert all the line of the source code o the byte code into
necessary machine code. This must be done prior it gets executed.
Figure 1: “Ways in which Interpreter works”
(Source: Eichhorn et al., 2018
3. Evaluating the memory management along with scoping features of
Commercia:
3.1. Discussion on memory management:
Commercia is meant to be a garbage collected language. It must be helping the developers in
managing the memory through periodic checking. Firstly, the garbage collector must be developing
its individual roots. These are the global variable. For this, the reference must be placed in the code.
Next, the roots are to be inspected and then it is marked as an active agent. This indicates that it is
Source Code Interpreter Output

6COMPARATIVE PROGRAMMING LANGUAGE
not garbage. Moreover, every piece of memory is not denoted to be active. It can be regarded as
garbage. Here, the collectors are able to free the memory. Then it can be returned to the operating
system (Wu et al. 2015).
3.2. Analysing the scoping features:
It can be stated that as one starts writing Commercia in the document, it can be said that the
person is already within the global scope. On the other hand, different variables that are defined
within the function can be considered to be within the local scope (Elaasar & Badreddin, 2016).
Here, they have a distinct scope regarding the call of that function. This indicates that the variables
have been possessing a similar name that can be used as various functions. The reason is that the
variables have been bound for the respective functions. They have been comprising of distinct
scopes. These are never accessible to the other functions.
4. Rationale and specification for the features of Commercia:
These can be demonstrated in terms of the following.
Simplicity:
Here, the core activities are able to run under any type of environment. Here, the pages can
turn unto more stable in nature having less to the errors of no codes. Next, there is no more
dependency on the no script regarding fallback (Alomari et al. 2015). Moreover, there is no necessity
to test and debug the verification of multiple browsers. It must be more secured instead of any
security issues. Here, there must be fewer codes to be run. It must make the web pages quicker to be
loaded. Moreover, there must be friendlier for mobile users. There must be a rise in robustness and
better for SEO attempts and search engines. Further, it must involve lesser time for development
with minimal expense of maintenance.

7COMPARATIVE PROGRAMMING LANGUAGE
Orthogonality:
This is the idea that the modules of Commercia must be written effectively. This must be
involved in such a way that there is a change in a single module. This must not need any
modifications in their modules. Here, two or more elements can be orthogonal as there are any
modifications that never impact others. Under a system that must involve data-base codes that must
be orthogonal. This is for the user interface. Here, one can modify the interfaces of Commercia. This
is despite affecting the database. One can also swap the databases in spite of changing the various
interfaces (Alic, Omanovic & Giedrimas, 2016). Here, orthogonality is the most vital property that
can be helpful to make complicated designs in compacts. Under the total orthogonal design of
Commercia, the operations never have any kind of side effects. Here, all the actions the changes are
the aspects that never affect other people. Here, there is a necessity to modify all the properties to
whatever system that are controlled. Here, the orthogonality is characteristic that indicates that the
changing of X never alters Y. For Commercia this indicates that as anyone executes the instruction,
here, instructions must be there which is highly vital for performing debugging (Korstanje et al.,
2016).

8COMPARATIVE PROGRAMMING LANGUAGE
Figure 2: “Violating orthogonality”
(Source: Samuel, 2017), pp. 37-57)
Data types:
Commercia must be providing distinct data types for holding various kinds of values. Here,
there must be two kinds of data types. The first one is a primitive data type. The next one should be a
reference on the non-primitive data type. The Commercia is expected to be a dynamic type. This
refers that one never require to specify the kind of variables. This is because it can be used
dynamically through the engine of JavaScript. Here, one requires to utilize var for specifying the
data types. This has been holding any kind of values like strings and numbers and so on (Georgiou,
Kechagia & Spinellis, 2017). The primitive data types must involve the “string” that denotes a
various sequence of characters. Then the number must denote the numeric values and Boolean that
must refer to Boolean values like either true or false. Next, the undefined must represent the
undefined value and the null representing the null having no value at all.
Next, regarding non-primitive data types, the object must be representing the example
through which one can access the members. Then, there is the “array that represents the team of the
same type of values. Lastly, there must be RegExp, denoting the regular expressions.
Syntax design:
Under the language of multi-paradigm, The JavaScript has been supporting various
functional imperative and event-driven. This must include the programming styles that are prototype
based, and object oriented. This consists of the APIs. This is meant to be working with various
regular expressions, dates, arrays and texts along with the DOM. However, here the language here
has not been including any Input/Output. This must include the graphics, storage and networking

9COMPARATIVE PROGRAMMING LANGUAGE
facilities. This has been depending on the environment of the host (Jordan et al., 2015). Here, it must
be embedded for providing those features. Along with the deployed client-side within the web-
browsers, the engines of Commercia has been included at various kinds of host software. This must
involve the server-side in databases and web servers. Here, various non-web programs like PDE
software and word processes must also be included. It might take place in the runtime scenarios
making Commercia write down desktop and mobile applications. This involves the widgets of
desktops.
Support for abstraction:
The abstraction of Commercia has been hiding particular details. They have been displaying
important features for the objects. They have tried to decrease and then factor out various details.
This is helpful such that the developers are able to concentrate on some ideas at any instant of time.
Here, the approach is helpful to develop the understandability along with maintainability of that
code. Moreover, it is useful to decrease the duplication of code. It paves the path to deal with various
crosscutting issues. It is also helpful to enable in avoiding the codes that are tightly coupled
(Kochhar, Wijedasa & Lo, 2016). Here, for Commercia the lack of abstraction can inevitably lead to
challenges regarding maintainability. Abstraction can be gained in Comerica through defining
various interfaces and then through using them. However, the interfaces have never been putting
impacts on the overall code of Commercia. This is the method to document the code for common
people. Lastly, it must be understood that it has been making the roles to be explicit. It has been
rising the maintainability, understandability and readability of the codes.

10COMPARATIVE PROGRAMMING LANGUAGE
Machine Code
statement
Machine Code
statement
Assembly language
statement
Assembly language
statement
High level language
statement
Not abstract
Moderately
abstract
Highly
abstract
Figure 3: “Understanding various levels of abstraction”
(Source: Abdallah & Al-Rifaee, 2017, p. 146)
Expressivity:
The expressiveness for Commercia is determined through the ability to express its arbitrary
algorithms. Thus, it indicates the ways how it can express any types of program. In this way, one can
encode the program in a presumable way. However, this is not an effective way of Commercia for
expressiveness. Here, one of the proxies indicates the number of lines the code has been changing to
every commit. It has provided the view of the way the expressiveness for all the language helps to be
in a similar arena of space (Kalbande & Chavan, 2016). This because there are various bugs in the
code. This is proportional to the number of source lines. Here, apart from the number of ideas
expressed, a more effective and expressive language is needed to be considered for that single alone.

11COMPARATIVE PROGRAMMING LANGUAGE
Type checking:
This must be catching most of the errors in runtime. This is prior to the developer for
production. This must be providing more amount of contexts across various runtime errors having
with different types. Moreover, the type checking can be used for tooling the code editors. The
designers can fetch errors just inline as one utilize the method and variable incorrectly (Jordan, et al.
2015). Moreover, Commercia can achieve autocomplete for various methods, object field and many
more. This should be including the libraries that one can import from the npm as they are various
available types.
Exception handling:
At Commercia all of the objects can be thrown. However, among these thrown objects can be
equally created. It is fairly common that the strings and numbers can be thrown as errors. This has
been frequently more efficient use one of the types of exceptions that are particularly generated for
the purpose. Here, a statement of throw must be provided for throwing the exception. As the
exception is thrown, one can specify the expression that consists of the value that is needed to be
thrown. For Commercia, expressions can be thrown. This should not include the expressions of
specific types only.