NPL: A Comparative Study of Programming Language Design Principles

This essay provides a detailed analysis of a new programming language, NPL, designed for the education sector. It explores the language's purpose, which includes comprehensive support for user interfaces, data exchange with servers, and managing educational activities like course registration and online learning. The essay discusses the choice of a compiled language and justifies this decision by highlighting the benefits of quick execution and optimization. It also covers scoping features, memory management using smart pointers for garbage collection, and the rationale behind major language features like simplicity, orthogonality, data types (including static, limited dynamic, and dynamic length strings), syntax design, support for abstraction, expressivity, and type checking. The essay emphasizes NPL's focus on decreasing complexity, ensuring orthogonality, and providing features that aid writability, expressivity, and abstraction, making it suitable for educational applications.

Running head: COMPARATIVE PROGRAMMING LANGUAGE
Comparative Programming Language
Name of the student:
Name of the university:
Author Note

1COMPARATIVE PROGRAMMING LANGUAGE
Study on Language Design:
The programming languages are formal languages specifying a various set of instructions.
These are used to yield desired outputs. They consist of various instructions for computing. Further,
they can use to generate programs capable of implementing particular algorithms.
In this essay, an arbitrary programming language is discussed that has no real life
resemblance. Its functionalities and features must allow the language to be suitable for the given
domain. Here, the programming paradigms include logic, functional, object-oriented and procedural
programming.
The study has provided a new name of the programming language, along with introduction
and explanation of the purpose of the language. It has included the choice and justification of
compilation methods and interpretation. Next, it has discussed scoping features and memory
management.
Name of the new programming language:
For this new idea, the language is named as NPL. This is the acronym for the new concept
“New Programming Language”.
Explanation of the language purpose:
This programming language is intended to be developed for the education sector. This area
has needed many applications to control large varieties of various tasks. Hence, the programming
language suits this area. It is expected to have comprehensive support for various user interfaces like
GUIs. It provides the ability to send and receive data to and from various servers. It must be helpful
to model real-world problems such as custom data types like supporting abstraction. Further, it
provides the ability to receive and data from various servers and different other devices. Besides, it

2COMPARATIVE PROGRAMMING LANGUAGE
must be able to control various course-registration related activities like grading systems, student
enrollments and so on.
Next, it should be handing online learning management related activities and manage
transactions in payments like paying tuition fees and many more. It must allow the usage of rich
multimedia capabilities for enabling video or sound playback. This must be helpful for creating
educational videos, supporting online lectures and conducting online conference meetings and so on.
The education sector has been encompassing various sectors like aspects of academic enrollment and
processing of results. This includes teaching and learning materials and managing finance. Lastly, it
must be reminded that the chosen programming language must comprise of various features like
reliability or maintenance of code, a flexibility of implementation and design, data types structures
and performance.
Choice and justification of compilation and interpretations used:
In designing the language, it decided to make it a complied language for the application
source code. Whether complied or interpreted, both have their strengths and weaknesses. Here, the
advantages of compilation language are used. There are many successful programming languages
that translated into running the source code with the help of the compiler. The outcomes in all the
effective code get executed many times. Overhead for the translation has been incurred just once
while the source gets compiled. Then it needs to be executed and loaded. It brings benefits like quick
execution and optimized for the target software. However, it must also be kept in mind that it needs a
complier and its deployment and editing of code is also slower than interpreters.
Here, one of the important benefits lies in the fact that those programs get complied gas they
are self-contained units that are already ready to get executed. Since they comply into machine
language binaries already, there is no second package or applications that are used by users to keep

3COMPARATIVE PROGRAMMING LANGUAGE
upgraded. As NPL gets compiled for Windows or x86 architecture, the end user would require only
Windows Operating system to run on x86 architecture. Moreover, any precompiled package would
run faster than interpreter compiling source code at a real time. As get locked on particular hardware
package, it has its downsides. Here compiling NPL can also raise its performance. Here users are
able to send particular options to the compilers about the details of hardware the program would be
running on. It has allowed compliers to create machine code making that most effective to use on
particular hardware. This has been opposed to more generic code. Further, it allows advanced users
to optimize the performance of programs on their computers.
Discussion on scooping features and memory management:
NPL would comprise of multiple-inheritance class mechanism with simple method dispatch.
It would be comprised of standard library functions for memory management. A higher level of
abstraction NPL would make bookkeeping needed for manual memory management harder. Though
standard library delivers manual memory management, NPL would be using smart pointers for
garbage collection as a solution. NPL can be using some stack allocated structures beyond their
lifetime and heap-allocated structures after freeing them. They must be neglected to free heap-
allocated objects as they no more needed. Further, there must be unexpected sharing because of
insufficient copying through copy constructors, allocation of insufficient memory for intended
contents and accessing arrays with the help of indexes that have been out of the bounds.
Here memory must be managed automatically. Memory must be allocated as an object is
created and reclaimed at some point as the object gets unreachable. The language must to supporting
finalization. Here the classes must possess functions of destructors that must run just as the object
reclaims by a memory manager. Further, the language must be supporting finalization and

4COMPARATIVE PROGRAMMING LANGUAGE
references. For NPL garbage collector under .NET Framework must be configurable for running soft
real-time under batch mode.
For NPL, the scope of the variable x is the sector of the program where uses of x denote the
declaration. Here one of the primary reasons of scope is to keep variables at various parts of the
program different from one another. As there have been just small numbers of names of short
variables, NPL must be developed in such a way that it must share habits for naming variables. For
example, this must use the alphabet “i” for array index in any program of mediocre size. It is the
same variable used for various scopes.
Rationale and specification for major language features:
These are discussed hereafter.
Simplicity:
It must be kept in mind, that NPL is simple does not only mean it is simplistic. It is about
lack of complexity. It is about decreasing incidental complexity for focusing on complexity that is
inherent to problems that are solved. However, it is possible to be wrong where decisions promote
simplicity in software. This indicates that developers of NPL require measuring simplicity.
Moreover, it is to be also accepted that foundation of NPL must be subject to subjective human
logic. This has framed conversations and intentions in a more useful way than any personal
preference. This decrease the total number of arguments as the remaining tends to be on the basis of
various interpretations of the same underpinning value. This helps in mutual understanding
respecting and understanding others. NPL must adopt the paradigm of radical simplicity. It must be
understood that from the code that we write to various processes we have been part, removes
unnecessary complexity actively allowing us to concentrate on various things that are equally
important.

5COMPARATIVE PROGRAMMING LANGUAGE
Orthogonality:
NPL must be orthogonal as its features are used without thinking about how it could be used
and affect other features. It is seen that features of programs that are compatible with the earlier
versions possess an orthogonal relationship have its features of earlier versions. This is because they
are mutually independent and one need not worry about how it used would result in unintended
effect. This is because of the interaction with features from other versions. Here both the programs
and features can be claimed to be mutually orthogonal. In the context of NPL, these set of features or
constructs are said to be orthogonal as they can be freely used in combination with one another. The
degree of orthogonality of NPL can be lessened when specific combinations get forbidden as in
exceptional cases. Further, the meaning of orthogonal would not be evident from various meanings
of its component elements, where each of them is considered without any regard or context.
Data types:
Regarding evaluation o data types, it must be kept in mind they must be an aid to writability
for NPL. The character strings must be implemented keeping the static length and limited dynamic
length strings. The static length is the compile-time descriptors having three fields including a name
of the type, length of the type and addressing the first character.
The next one is the limited dynamic length string. This, in turn, has needed a run-time
descriptor for length for storing both fixed maximum length and current length. Then there are
dynamic length strings. They need run-time descriptor due to present length needs to get stored.
Further, there are deallocation and allocation that is the biggest implementation problem. Here,
storage to which it is bound should rise and shrink dynamically.

6COMPARATIVE PROGRAMMING LANGUAGE
Syntax design:
The various syntaxes of NPL must explain its programs to users. Particularly, a structure in
NPL must be made explicit with the help of syntax. The syntax should be concise. Here, the
converses have been that the syntax must be always added to explanation. The syntaxes that never
add value can never obscure the explanation of NPL. Further, the syntax must confirm that there
various things that people have been learning from daily life and it must not be forced to unlearn
those things. Further, there are many things that users earn from their daily life. These things must
not be unlearnt. The syntax of programming languages has been more vital than idealized by most
users. It must make the difference in writing clear code for NPL. However, syntaxes can be
mysterious and unable to decipher without any tons of comments. Here, for most applications, there
has been no appreciable distinction between languages in terms of user experiences. The algorithms
have been far more likely the issue most of the time.
Support for abstraction:
Abstraction in NPL must indicate that various qualities are to be focused instead of any
particular example. Abstraction indicates that NPL would automatically discard what has been
irrelevant or unimportant. It is one of the vital principles for NPL and is closely related to ideas like
polymorphism, inheritance and encapsulation. It must be applied for identifying objects for modeling
the problem domain. This process decreases those objects to their essence that is only needed for the
elements represented. Further, it defines objects according to its properties, interface and
functionality or in other words the means to communicate with various other objects. Those methods
are used for reducing the complexity of design and process of implementation software. In this
process, designers have been defining abstract actors of the objects that can perform tasks, change

7COMPARATIVE PROGRAMMING LANGUAGE
the state and make communication with various other actors. The state of an object gets encapsulated
as the in-detailed data structures are associated with objects that are kept beyond the scenes.
Expressivity:
It denotes to the capability of NPL to express the solutions to its various problems. This can
be done in the closest way to the primary problem formulation. It must be concise, intuitive, natural
and clear in relation to other solved problems. This definition has not been in formalized and not free
from criticism. Further, it is useful to consider the language more expressively than others. Here,
from this perspective, it has been clear that NPL has comprised of subroutines has been more
expressive than languages without them. There are procedures that allow writing various pieces of
programs in natural language including a name of procedures. These procedures must allow writing
programs for NPL in natural language. This example has also served to notice that the definition has
been sometimes hard to follow without any contradiction. Programs with proper use of subroutines
have been less concise than the corresponding programs without them. This definition has been
particularly suitable for NPL has it is thought to be a declarative language.
Type checking:
It is done through the type checker that verifies that this type of construction has been
matching what has been expected in the context of usage. It has ensured that various kinds of
programming errors get reported and detected. Here type checker of NPL also needs to know that
syntactic constructs in a language such as operators. This also includes basic type language and rule
to assign a type of constructs. For NPL at static type checking, the checking must be done during
compile-time. While using the languages users of NPL are needed to be enforced for declaring a
type of variables before it gets used. The compiler needs to know what data type has been the
variable belongs to.

8COMPARATIVE PROGRAMMING LANGUAGE
Next, there is dynamic type checking where type checking is been done at runtime. While using
these languages one need to specify or declare various kinds of variables in spite of compiler has
been figuring out what kind of variable needed while its value is assigned.
Exception handling:
The exceptions can be handled in many ways. For NPL, no matter what occurs, here, no
exception must be thrown. In case operations get failed, the exceptions must be thrown. As in the
case, systems continue to run, it must be kept in mind that no resources for NPL get leaked anyway.
However, go ultimate guarantees can be made and this is the worst level of exception safety.
Restricted aliasing:
Here all the qualifiers are to be arranged under a subtyping hierarchy in NPL. These
restricted qualifiers are the super-type of every other kind of qualifiers. These restricted pointers can
never be freed and here no such aliases of the pointers get created.
Reliability, writability and readability of NPL:
There are various reasons why the success of any language depends on the characteristics of
the language. Various characteristics are crucial to make NPL a good one.
Readability: Lots of factors are there to determine whether NPL is a readable or not. Here, the most
important one is familiarity. The human mind has gone in adapting and it has been astonishing what
this mind perceives to be normal. Familiarity is a constant exposure. However, it denotes that NPL
having a relatively simple syntax must turn out to be familiar quickly.
Writability: It is the measurement of how NPL can be utilized easily for creating a particular
problem domain. Readable characteristics of NPL also affect its writability. This is because that the
process to write NPL needs the developer to reread that part of the program written already.

9COMPARATIVE PROGRAMMING LANGUAGE
Writability is also seen in the context of a targeted domain of problem of languages. The most
important features that must influence writability of NPL are many. The first one is the orthogonality
and simplicity. As any language possesses a huge number of distinct constructs, here, some of the
programmers have not been familiar with every one of them. The situation leads to the misuse of
various features. Then there is support of abstraction. This indicates the ability to define and utilize
complicated operations and structures such that it allows variously detailed to get ignored.
Abstractions in many ways have allowed the design of various programming languages. The next
one is expressivity. For NPL it refers to various distinct characteristics. This indicates that there are
very powerful operators allowing a great deal of competition that is needed to be accomplished with
a very small program.
Reliability: It is the attribute present in NPL that is needed to consistently perform as per the
specifications. For NPL it is one the related attributes that are needed to b considered. String systems
like NPL must encourage reliability of code. Here most of the errors are type errors. Here dynamic
typing is very helpful. However, it is unreliable. Different lower-level features of NPL such as
pointers, manual memory management and then an absence of runtime checking have made it
complex to write reliable programs like NPL. The reliability of programming language indicates the
ways in which crash-proofing of any code gets written in NPL. Further, it is highly dependent on
NPL’s code and very less on the language. Besides, a reliability of NPL must never be dependent on
how easier it has been to get programmed, though it has been highly application-specific.
In the above discussion, NPL is structured as a pipeline. It was comprised of various stages.
Every stage comprises of data that are formatted in specific and in a well-defined method. Further, it
also comprises of function to transform data from every stage to the next. In the first stage, it was
comprised of an entire input source file. The final stage of NPL is meant for its effective run. The

10COMPARATIVE PROGRAMMING LANGUAGE
essay is helpful to level a common framework for understanding how various different programming
languages have been behaving and in what manner. It also helps to study and classify various
programming languages. However, to understand the various choices available it can be also utilized
to guide the implementation of NPL. The study has demonstrated various aspects and various
features of NPL from functional and logical ones. It has also covered various steps and parts of
implementation to use NPL as an intermediate language for linking, within virtual machines and so
on. The discussion would also impact the ability to design various compilers and programming
languages in future. NLP has a strong theoretical support and also explains the practical significance
of individual idea. However, it must be reminded that these principles must not be taken as dicta.
Good judgment must be used. Designing principles of NPL, as followed blindly must lead to
disaster. These principles discussed above can be orthogonal and frequently conflict.

11COMPARATIVE PROGRAMMING LANGUAGE
Bibliography:
Aruoba, S. B., & Fernández-Villaverde, J. (2015). A comparison of programming languages in
macroeconomics. Journal of Economic Dynamics and Control, 58, 265-273.
Bosshart, P., Daly, D., Gibb, G., Izzard, M., McKeown, N., Rexford, J., ... & Walker, D. (2014). P4:
Programming protocol-independent packet processors. ACM SIGCOMM Computer
Communication Review, 44(3), 87-95.
Chamberlain, R. D. (2017, October). Assessing user preferences in programming language design. In
Proceedings of the 2017 ACM SIGPLAN International Symposium on New Ideas, New
Paradigms, and Reflections on Programming and Software (pp. 18-29). ACM.
Chapman, K., Hosking, A. L., Moss, J. E. B., & Richards, T. (2014, September). Closed and open
nested atomic actions for Java: Language design and prototype implementation. In
Proceedings of the 2014 International Conference on Principles and Practices of
Programming on the Java platform: Virtual machines, Languages, and Tools (pp. 169-180).
ACM.
Coblenz, M. (2017, May). Principles of usable programming language design. In Proceedings of the
39th International Conference on Software Engineering Companion (pp. 469-470). IEEE
Press.
Feo, J. T. (Ed.). (2016). A comparative study of parallel programming languages: the Salishan
problems. Elsevier.

12COMPARATIVE PROGRAMMING LANGUAGE
Frey, B., Doddridge, J., & Seaman, C. (2017, October). Chasing the AHA! moment: Exploring
initial learnability of programming languages. In Visual Languages and Human-Centric
Computing (VL/HCC), 2017 IEEE Symposium on (pp. 329-330). IEEE.
Gao, H., Qiu, Z., Wu, D., & Gao, L. (2015, January). Research and reflection on teaching of C
programming language design. In International Conference of Young Computer Scientists,
Engineers and Educators (pp. 370-377). Springer, Berlin, Heidelberg.
Gordon, A. D., Graepel, T., Rolland, N., Russo, C., Borgstrom, J., & Guiver, J. (2014, January).
Tabular: a schema-driven probabilistic programming language. In ACM SIGPLAN Notices
(Vol. 49, No. 1, pp. 321-334). ACM.
Gorinova, M. I., Gordon, A. D., & Sutton, C. (2018). SlicStan: Improving Probabilistic
Programming using Information Flow Analysis. In Workshop on Probabilistic Programming
Languages, Semantics, and Systems (PPS). https://pps2018. soic. indiana.
edu/files/2017/12/SlicStanPPS. pdf.
Hoc, J. M. (Ed.). (2014). Psychology of programming. Academic Press.
Howland, K., & Good, J. (2015). Learning to communicate computationally with Flip: A bi-modal
programming language for game creation. Computers & Education, 80, 224-240.
Howland, K., & Good, J. (2015). Learning to communicate computationally with Flip: A bi-modal
programming language for game creation. Computers & Education, 80, 224-240.
Karsai, G., Krahn, H., Pinkernell, C., Rumpe, B., Schindler, M., & Völkel, S. (2014). Design
guidelines for domain specific languages. arXiv preprint arXiv:1409.2378.

13COMPARATIVE PROGRAMMING LANGUAGE
Nanz, S., & Furia, C. A. (2015, May). A comparative study of programming languages in Rosetta
Code. In Software Engineering (ICSE), 2015 IEEE/ACM 37th IEEE International
Conference on (Vol. 1, pp. 778-788). IEEE.
Rajan, H., & Leavens, G. T. (2015). Design, semantics and implementation of the Ptolemy
programming language: A language with quantified typed events.
Rastogi, A., Hammer, M. A., & Hicks, M. (2014, May). Wysteria: A programming language for
generic, mixed-mode multiparty computations. In Security and Privacy (SP), 2014 IEEE
Symposium on (pp. 655-670). IEEE.
Sawada, K., & Watanabe, T. (2016, March). Emfrp: a functional reactive programming language for
small-scale embedded systems. In Companion Proceedings of the 15th International
Conference on Modularity (pp. 36-44). ACM.
Smart, J. (2017). Design of a new programming language.
Stefik, A., & Hanenberg, S. (2014, October). The programming language wars: Questions and
responsibilities for the programming language community. In Proceedings of the 2014 ACM
International Symposium on New Ideas, New Paradigms, and Reflections on Programming
& Software (pp. 283-299). ACM.
Tan, A. T., Falcou, J., Etiemble, D., & Kaiser, H. (2016). Automatic task-based code generation for
high performance domain specific embedded language. International Journal of Parallel
Programming, 44(3), 449-465.
Tolpin, D., van de Meent, J. W., Yang, H., & Wood, F. (2016, August). Design and implementation
of probabilistic programming language anglican. In Proceedings of the 28th Symposium on
the Implementation and Application of Functional Programming Languages (p. 6). ACM.

14COMPARATIVE PROGRAMMING LANGUAGE
Tunnell Wilson, P., Pombrio, J., & Krishnamurthi, S. (2017, October). Can we crowdsource
language design?. In Proceedings of the 2017 ACM SIGPLAN International Symposium on
New Ideas, New Paradigms, and Reflections on Programming and Software (pp. 1-17).
ACM.
Urma, R. G., & Mycroft, A. (2015). Source-code queries with graph databases—with application to
programming language usage and evolution. Science of Computer Programming, 97, 127-
134.