NPL - A New Programming Language For Education Essay.

Programming Paradigms include Logic, Functional, Object-oriented and Procedural Programming

Discuss design a programming language for the problem domain of Education Sector.

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.

For this new idea, the language is named as NPL. This is the acronym for the new concept “New Programming Language”.

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 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.

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.

Choice and Justification of Compilation Methods and Interpretation

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 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.

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 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.

Scoping Features and Memory Management

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.

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.

Name and Purpose of NPL

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.

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 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.

NPL designed for Education Sector

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.

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.

Comprehensive Support for Various User Interfaces and Modeling Real-world Problems

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.

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. 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. 

Performance and Simplicity of NPL

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 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

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.

Orthogonality of NPL

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.

 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.

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.