Comparative Programming Language

This report discusses the features and benefits of Commercia, a new programming language for developing e-commerce sites. It covers topics such as interpretation methods, memory management, scoping, and the rationale behind the language's features. The report also evaluates the readability, writability, and reliability of Commercia.

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.

12COMPARATIVE PROGRAMMING LANGUAGE
Figure 4: “Types of Exceptions for Commercia”
(Source: Created by Author)
Restricted aliasing:
The standards chosen for Commeria must specify what types of expressions are to be
permitted for aliasing for what types. Here, the optimizer ad compiler should be permitted in
assuming whether Commercia must be following the rules of aliasing very strictly. They should
make an attempt in attempting access with the values. This must be done using a type that is not
permitted. This must be classified as the UM or Unified Behavior (Kochhar, Wijedasa & Lo, 2016).
As the behaviors are undefined, every bet can get off. Here, the outcomes of the programs are never
dependable more. Through violating the restricted aliasing, unfortunately, Commercia must generate
the results as expected. It must leave the probability that the future version of the compiler with the
latest optimization and break the code as though to be valid. It is undesirable and a worthwhile aim
in understanding the rules of restricted aliasing along with the ways to avoid n violating them.
Throwable
Exception
Runtime
Exception
Additional
exception
Error

13COMPARATIVE PROGRAMMING LANGUAGE
5. Readability, writability and reliability of Commercia:
5.1. Discussing the readability:
In order to write and design effective pieces of code, developers of Commercia must move
beyond the restrictions of modern and suitable syntax. It is vital to accept reviews of constructive
codes. This should be including creational patterns. This must be focusing on optimizing the creation
of latest objects. This suits the case where they have been working. Here, the primary method
regarding creating the objects has been including complexities of design (Abdallah & Al-Rifaee,
2017). Thus the patterns are helpful to eradicate those complexities. Here, the structural patterns are
concerned with how various objects are made up. They should be simplifying the relationship
between various objects. Here, the patterns must assure that the objects are structured such that, as
one part of the system alters, the complete structure of the system never requires to perform the
same. Further, the behavioral design patterns have been concerned with assigning of liabilities. This
must be taking place between various objects and the ways in which the objects have been
communicating. Here, some of the behavioral patterns have been including command, observer and
mediator.
5.2. Analyzing writability:
The writability of Commercia must be done in such a way that it is can easily it can be
utilized for creating programs. This is for the problem domain chosen. Its most characteristics
affecting the readability has also been affecting writability. It can be followed directly from the
reality that the method to write the program needs to reread specific parts of the code. This art must
be already rewritten (Yamazaki et al. 2015). Furthermore, the writability of Commercia should be
taken into consideration at the content of the domain of the target problem of the language. Here, it

14COMPARATIVE PROGRAMMING LANGUAGE
is never simply reasonable in comparing the writability of various languages. This is under the realm
of the specific application as some are designed for the sake of the application, while the other is not.
5.3. Reliability evaluation:
While choosing Commercia, it is important to think about the extent to which it is reliable
has been. Here, they should be thinking about things like the probability of crashing like as any user
might input various abnormal information to that. Here, the language having the dependability
having less than ten per cent can be chosen unlikely for the safety and mission critical system of
Commercia. This indicates that the way how cash-proof is the code written in the language. It is
highly dependent on the written code having very small on the language (Belyakova, 2016). Besides,
the reliability has been depending on how simply the program in the language has been highly
specific application. This also indicates how cash-proof the code is written in the language.
Reliability is largely dependent on the code written and very little on the language itself.
However, reliability does depend on how easy it is to program in that language although it is largely
application-specific. It is also helpful to put suitable emphasis on that. It is primarily the financial
concern and never a technical issue (Salvaneschi, Margara & Tamburrelli, 2015). Then, most of the
programmers have been enjoying the development of any program. Hence, making Commercia
should be enjoyable as directly opposed to various approaches to make programs more dependable.
At last, a few of the theoretical tasks on the correctness of Commercia is much abstract. This
is complicated for various programmers in understanding and much expensive for ecommerce
business for using. Here, for the applications of Commercia, a minute and incremental rise in
dependability or incremental and small rise in an effort of the programmer.

15COMPARATIVE PROGRAMMING LANGUAGE
6. Conclusion:
It is seen that presently the e-commerce websites are turning popular for marketing over the
Internet. Hence, for the developers of Commercia, they must not worry much about its business.
Here, the platforms for the e-commerce business must permit users to create functional and attract
online stores. This is to drop and drag the interfaces. At the previous stages, it has been possible
working fine. Commercia is useful here for apps, animations and additional smart, dynamic impacts.
It is required here as a various fancy type of features attractive graphs on the e-commerce site is
required. As demonstrated in the above study, the programming language chosen here is able to
handle every aspects and function of the rising store of eCommerce. Moreover, it must be kept in
mind that one never need to code the complete website. There are numerous entrepreneurs who have
not been familiar with coding has been utilizing the eCommerce builder. This is to develop the
required site instead. This is easier, helpful and simpler to get on the building of the business
quicker. Lastly, it can be said that there has been no best programming language. Thus the
programmers who are the best. Thus, developers of Commercia must be hired as per the best option
in the market.

16COMPARATIVE PROGRAMMING LANGUAGE
7. References:
Abdallah, M. M., & Al-Rifaee, M. M. (2017). Java Standards: A Comparative Study. International
Journal of Computer Science and Software Engineering, 6(6), 146.
Abdallah, M. M., & Al-Rifaee, M. M. (2017). Java Standards: A Comparative Study. International
Journal of Computer Science and Software Engineering, 6(6), 146.
Alic, D., Omanovic, S., & Giedrimas, V. (2016, May). Comparative analysis of functional and
object-oriented programming. In 2016 39th International Convention on Information and
Communication Technology, Electronics and Microelectronics (MIPRO) (pp. 667-672).
IEEE.
Alomari, Z., Halimi, O. E., Sivaprasad, K., & Pandit, C. (2015). Comparative studies of six
programming languages. arXiv preprint arXiv:1504.00693.
Belyakova, J. (2016, September). Language Support for Generic Programming in Object-Oriented
Languages: Peculiarities, Drawbacks, Ways of Improvement. In Brazilian Symposium on
Programming Languages (pp. 1-15). Springer, Cham.
Eichhorn, H., Cano, J. L., McLean, F., & Anderl, R. (2018). A comparative study of programming
languages for next-generation astrodynamics systems. CEAS Space Journal, 10(1), 115-123.
Elaasar, M., & Badreddin, O. (2016, October). Modeling meets programming: a comparative study
in model driven engineering action languages. In International Symposium on Leveraging
Applications of Formal Methods (pp. 50-67). Springer, Cham.
Feo, J. T. (Ed.). (2016). A comparative study of parallel programming languages: the Salishan
problems. Elsevier.

17COMPARATIVE PROGRAMMING LANGUAGE
Georgiou, S., Kechagia, M., & Spinellis, D. (2017, September). Analyzing Programming Languages'
Energy Consumption: An Empirical Study. In Proceedings of the 21st Pan-Hellenic
Conference on Informatics (p. 42). ACM.
Jordan, H., Botterweck, G., Noll, J., Butterfield, A., & Collier, R. (2015). A feature model of actor,
agent, functional, object, and procedural programming languages. Science of Computer
Programming, 98, 120-139.
Jordan, H., Botterweck, G., Noll, J., Butterfield, A., & Collier, R. (2015). A feature model of actor,
agent, functional, object, and procedural programming languages. Science of Computer
Programming, 98, 120-139.
Kalbande, D. T., & Chavan, S. P. (2016). ICT Skills among Agricultural College Librarians: A
Comparative Study. International Research: Journal of Library & Information Science, 6(4),
674-682.
Kochhar, P. S., Wijedasa, D., & Lo, D. (2016, March). A large scale study of multiple programming
languages and code quality. In 2016 IEEE 23rd International Conference on Software
Analysis, Evolution, and Reengineering (SANER) (Vol. 1, pp. 563-573). IEEE.
Kochhar, P. S., Wijedasa, D., & Lo, D. (2016, March). A large scale study of multiple programming
languages and code quality. In 2016 IEEE 23rd International Conference on Software
Analysis, Evolution, and Reengineering (SANER) (Vol. 1, pp. 563-573). IEEE.
Korstanje, R., Brom, C., Gemrot, J., & Hindriks, K. V. (2016, February). A Comparative Study of
Programming Agents in POSH and GOAL. In ICAART (2) (pp. 192-203).
Noone, M., & Mooney, A. (2018). Visual and textual programming languages: a systematic review
of the literature. Journal of Computers in Education, 5(2), 149-174.

18COMPARATIVE PROGRAMMING LANGUAGE
Paiva, J. C., Leal, J. P., & Queirós, R. A. (2016, July). Enki: A pedagogical services aggregator for
learning programming languages. In Proceedings of the 2016 ACM Conference on
Innovation and Technology in Computer Science Education (pp. 332-337). ACM.
Rathi, D., & Given, L. M. (2017). Non-profit organizations’ use of tools and technologies for
knowledge management: a comparative study. Journal of Knowledge Management, 21(4),
718-740.
Ronszcka, A. F., Ferreira, C. A., Stadzisz, P. C., Fabro, J. A., & Simão, J. M. (2017, November).
Notification-oriented programming language and compiler. In 2017 VII Brazilian Symposium
on Computing Systems Engineering (SBESC) (pp. 125-131). IEEE.
Salvaneschi, G., Margara, A., & Tamburrelli, G. (2015, May). Reactive programming: A
walkthrough. In 2015 IEEE/ACM 37th IEEE International Conference on Software
Engineering (Vol. 2, pp. 953-954). IEEE.
Samuel, M. S. (2017). An Insight into Programming Paradigms and Their Programming Languages.
Journal of Applied Technology and Innovation, 1(1), 37-57.
Wu, D., Chen, L., Zhou, Y., & Xu, B. (2015). A metrics-based comparative study on object-oriented
programming languages. State Key Laboratory for Novel Software Technology at Nanjing
University, Nanjing, China, DOI reference number, 10.
Yamazaki, S., Sakamoto, K., Honda, K., Washizaki, H., & Fukazawa, Y. (2015, January).
Comparative study on programmable robots as programming educational tools. In
Proceedings of the 17th Australasian Computing Education Conference (ACE 2015) (Vol.
27, p. 30).

19COMPARATIVE PROGRAMMING LANGUAGE
Yang, S., Mao, X., Ge, B., & Yang, S. (2015, October). The roadmap and challenges of robot
programming languages. In 2015 IEEE International Conference on Systems, Man, and
Cybernetics (pp. 328-333). IEEE.