Overview and Purpose of the Programming Language

The name of my programming language is Radiohead. The purpose of this programming language will provide scientific calculation, and the primary purpose of this programming language will give instruction to the computer. The natural language has many errors, whereas this programming language does as it will be instructed. The programmer of this language needs to specify the internal behavior, which will be occurred at the execution stage of programming. This language will be altered according to the needs of the user. It will be a universal language, which serves all the purpose. This language's programs will have the balance speed, size, and simplicity from microcomputers to supercomputers. The program will be written, and it will not change for generations. It will undergo constant modifications for a successful outcome. It will discuss the problem and solve them in a particular language, which will be beneficial for all the programmers (Hunt, & Sinyavskiy, 2016).

The development of this programming language will add more features to solve the problems using a high abstraction level. Other programming languages are closely tied to the hardware of the computers. The programmers can express their ideas, which will be removed from the simple translation of the hardware instructions. This language will be less tired of the computer's requirement, and the programmers can do more computing with less effect. It will help the programmers to write more programs in a short amount of time. The main difference between this programming language and other programming languages is the unique method of code execution. It will compile into byte code and run in any device, which will have this language's virtual machine (Yin, & Neubig, 2017).

On the other hand, C++ is compiled into the machine code, and it runs only the same platforms where it is assembled. Another unique feature of this language will be the library class. The syntax of the Radiohead will be

Expression: = number/ Symbol Number: = {+-}/ {0 to 9} + Symbol: = {‘A’, ‘B’, ‘C’}

List: = "('Expression')"

The expression of this language will be the list. It can be a number or symbol. The number is the sequence one or more digits of decisional, and it will have the addition and subtraction sign. The symbol is the character, which will be more than one character or the expression. The list will be the matched parentheses pair with more expression inside it (Srinath, 2017).

Interpretation and Compilation Method

Radiohead will be the platform-independent programming language that will do not work on the single-step compilation. The will have two steps compilation, such as the operating system's impendent compiler and the virtual machine, which is custom-built for different operating systems. Firstly, the programming file will go through the compiler, which encodes the source code into machine-independent language, and the content will be stored in a separate file. While converting the source code into the byte code, the compilers will follow several steps.

Once the program will be written and saved, and it will be needed to compile. In order to compile the program from the line of command, the programmers will need to invoke the appropriate compiler with the help of providing command (Amy, Roetteler & Svore, 2017). The compile of this programming language is the software that will be necessary to develop the application of Radiohead programming language. This programming development kit will include the runtime environment, API classes, compiler, and additional files for the Radiohead language's applets and applications. Compile of the HelloWorld.rh will be the # radioheadcomplie.helloworld.rh. This compile will create the file name HelloWorld.rh, containing the program's byte code. The byte code of this programming language will represent the program files that will include the instruction of the interpreter of this language. The compiler will not execute the program. It will be done by the virtual machine of this programming language, and it will not execute the program directly. The compiler will translate the source code into the program file then the virtual machine will execute the program properly. The compiler of this language can compile multiple programs together. There will be more than one source file in the same directory, and then it will either list the files by the spaces or the character (Sestoft, 2017).

After a successful compilation of the HelloWorld.rh, it will run the program with the use of a Radiohead interpreter. In order to pass the program file as the command line argument is showing below

# Radiohead HelloWorld

The message will print the hello world on the screen. It is seen that the command line of this program will omit the .rh extension of the byte code name of the file. The command line will invoke this programming language's virtual machine, and then it will load the specified program name mentioned at the command line. It will invoke the primary method of the program, and it will start executing this method. It will be a single argument, which is the string array. The array will pass the strings to the primary method for receiving the command line. The virtual will take various steps to run the program of Radiohead programming language (Weng, 2019). Loading will be the process of finding the binary form of the class or the interface with a specific name from the source code with the compiler's help. It will be the simple byte code. It will be the initial effort to execute the program's primary method, where the virtual machine will see that the program will not be loaded. Thereby the virtual machine of this language will not have the binary representation of the program. After that, it will use the loader to load the program in the memory. Besides, the program will not be found, and then it will throw an error. Linking will be the process to take the binary form of the class or interface, and it will combine in the runtime state of the Radiohead's virtual machine. Once the program loads, it will need to be initialized before the main invoking method (Kiselyov,2018). It will involve verification, preparation, and resolution. Verification will make sure that the binary representation of the class or the interface is correctly structured. The preparation will create the static field for the class or the interface, and it will initialize the fields to its default values. The resolution will be the process, which will check the symbolic references from the programs to the other class and interfaces to load additional classes that will contain the correct references.

Memory Management and Scoping Features

Memory management is allocating new objects and removing the unused items to make space for the new objects. The Radiohead will manage then memory, and it will no need for then explicating intervention of the programmer. It will be essential for this programming language to manage memory effectively without any leaks. This programming language will critically allocate and de-allocate memory. The virtual machine of this language will specify the garbage collection, and it will manage memory allocation so that the programmer will not need to allocate the memory. However, other programming languages like C can access the memory that allocates in the program code (Baxter, 2017). Thus, it creates many memory leaks. The major components of the memory management of the Radiohead will include the virtual machine structure and garbage collector. The Radiohead virtual machine will define various runtime data used during the program's execution stage. Many areas will be created by this virtual machine, where some will be created by the threads which will be used by the program. Besides, the memory will be created by the VM, and it will be destroyed when the VM exits. The data thread areas will be created during the initiation phase, and it will be destroyed when the threads exit.

The heap will store the actual objects. It will be created when the VM of this programming language will start. The program can control the head area if required and can be fixed and dynamic according to the size. The developer will need to use the new keyword to create the instance of the object in the heap area (Jones, Hosking, & Moss, 2016). While referencing the object that will store in the stack, it will exist one heap for each process running on a virtual machine of this programming language. The garbage will be collected when the heap area will full.

# StringBuilder rh: new StringBuilder

The above command will create the object of the String Builder class. The object will allocate to the heap area, and the reference of rh will allocate to stack.

There will be four types of references for the Radiohead programming languages, such as strong, weak, soft, and phantom. The different references will be the object on the heap area that will refer to the eligible objects for collecting the garbage under the different requirements. The strong references will use in daily programming. The object, which will attach to the strong reference, will not be permitted for garbage collection. The following command will create a strong reference (Raghunathan et al., 2016).

StringBuilder rh: new StringBuilder{};

The weak reference of the Radiohead will not survive after the process of garbage collection. Data will request again when it will not make sure. Based on this situation, the programmer can create a weak reference object of this programming language. The collector can destroy the item. It will return the null when the programmer tries to retrieve the object after the collection. The programmer can create a weak reference with the help of the following command

WeakRef StringBuilder rh : new WeakRef { new StringBuilder{}};

The soft reference will be collected when the application will be running in low memory. The collector of garbage will not collect the objects, which will be softly reachable. All the soft referenced objects will be collected before the error of out of memory. The soft reference can be created

SoftRef StringBuilder rh : new SoftRef { new StringBuilder{}};

The phantom reference will be available on the Radiohead.ref package. It will be defined in Radiohead.ref.PhantomRef. This object will have only pointing to the objects of phantom reference, and it can be collected whenever the garbage collector wanted (Kannan et al., 2017).

The stack area will generate when the thread is created. It can be fixed or dynamic in size. The memory will allocate according to the thread, and it will be used for storing data and results. It will contain the reference to the heap area objects. It will hold value rather than the object from the heap area. The variable, which will be stored in the stack, will be known as the scope. The stack frame will be the data structure that will contain the thread data. This data will represent the current method of the thread. It will use for storing the result and data that will perform dynamic linking, return value methods, and exception. A new will create when the method invokes. It will de-allocate the frame when the invoking of the method is done. Every frame will contain the local variable, operand stack, and framed data (Cservenka, 2018).

The size of these variables will be determined at the compiled time of the program of the Radiohead. The native stack will be known as the stack. It will contain the native code, which will be written in a language rather than the Radiohead. The interface of this programming language will be known as the native stack. The performance of this stack will depend on the operating system.

Every thread will have the register of the program counter, which will associate with it.

It will store the return address and the pointer of the native stack. It will also contain the address of VM, which will currently be executed. The virtual machine of this programming language will control the garbage collector. It will decide when to perform the collection of garbage. It can request the VM to complete the collection process, and the virtual machine will run the collection process if it senses the low memory. There will be five garbage collection types in the Radiohead programming language, such as serial, parallel, old parallel, CMS, and garbage collector (Guatto el al., 2018).

Specification and Rationale of Language Features

Radiohead is a general-purpose, class-based, object-oriented programming language. It will design to be simple. Thus, all the programmers can improve fluency in this programming language. It will be related to other programming languages such as C and C++. Besides, it will be organized differently. Simplicity will be one of the designing objectives of the Radiohead programming language. Another designing goal of this programming language will be to look similar to most developers on the computer. The programmer can relate this language to other languages. The sample program of the Radiohead is given below (Huo, Li & Zhou, 2016).

Class HelloWorld [

Static public main {String ()} [ System.out:" Hello World";

]

]

The example will declare the class name called HelloWorld. Within this class, there will be a single method called the main {}, which will display the word "Hello World."

There will be three types of data types in this programming language, such as numeric, character, and Boolean. Radiohead programming language will follow the C, C++, regarding the basic data types with a minor exception. The numeric data type will be eight, sixteen, thirty-two, and sixty-four bytes. The real numeric will be 32 bit for float and 64 bit for double. The character data type of this programming language will be related to C. The character type data will be 16 bit Unicode (Al-hassy, Carette & Kahl, 2019). It will be the 16-bit values that will define the code of character from 0 to 65,000. The character can be defined as char : newChar: 'I.'

The Unicode value of the above declaration will be the I. Boolean data type will be primitive, and it will be rectifying from the existing languages like C and C++. The value of the Boolean variable will be true or false. It will be a distinct data type of the Radiohead programming language, and it will not be converted to any numeric values.

Orthogonality of the Radiohead will be the features that can be used in combination. It will be a relatively small set of the construct that will combine in a few ways to manage the structure and construct data. Every structure will be legal in this programming language. There will be three data types and two operators, such as array and pointer, that can create many data structures. It will make this programming language simpler and regular due it will have less number of exceptions (Duhoux, Mens & Dumas, 2019).

The Radiohead will be the collection of the object that will communicate by invoking each other's methods. The syntax will derive from different languages like C, C++. There will be no global functions and variables, and the data member will be considered as the global variable. All the code will be the class, and the values will be the objects in the Radiohead programming language. The feature like operator overloading and unassigned integer will be omitted to ignore programming language. It will make this language simpler. The identifiers of this language will be the code element. The identifiers will contain Unicode character like letter or digit, the sign of currency, connecting character, etc. It cannot start with a digit, and it cannot be null or Boolean (Srinath, 2017).

The abstraction of this programming language will be the process of removing the characteristics to reduce the set of significant characteristics. It will be one of the essential principals of this programming language. With the help of abstraction, the developer can hide all the data about the object for more efficiency. It will reduce complexity, as well. It will help to omit all the unnecessary detail of the objects of this programming language (Ezenwoye, 2018).

This programming language's expressivity will be the scope of ideas, and that can be represented and communicate in this programming language. It will be an expressive programming language. Thus the variety and the number of ideas will be used to represent (Ezenwoye, 2018).

The type checking of this programming will be done on compile. Thus the type checking will be known as static type checking. The information about the value types in this program will be accessible in the execution time. Thus it will increase the execution time, reliability of the execution code. Therefore this Radiohead will be known as static type checking programming language. It will guarantee that errors of type-related will not occur during the execution of the program (Ezenwoye, 2018).

The exception handling will be the process that will handle the errors at the runtime related to exceptions like class not found, SQL, Remote, etc. The exception handling of this language will maintain the flow of the program. There will be three types of exceptions, such as checked, unchecked, and error. The class of this language will be inherited from the Throwable class except for the runtime and error exception. The classes which will inherit the RuntimeException will be known as the unchecked exception of the Radiohead. The error will be irrecoverable (Srinath, 2017).

Aliasing, this programming language will be more than one alias to the location, which will be updated, and these aliases will have different types.

Box 1 = New Rectangle {0, 0,100}     X: 0, Width: 100

Box 2 = Box 1;     Y: 0, Height: 200

The two boxes point to the will point to the same object. This object will have two names, like box one and box 2. It will be known the anti-aliasing of this programming language (Srinath, 2017).

Readability, Writability and Reliability

The readability of the Radiohead will depend on the readers. This language will have many predecessors, making this language related to other programming languages to adopt this programming language's unique environment. The bracket use will represent the program block, which can improve to organize the complex programs. The compound command can explain themselves that will make this language easier to understand in simple English. This programming language will be case sensitive. Thus the variable should have the same capitalization throughout the program while the keyword should be in lower-case. It will prevent the readers from checking to ensure that the variable name and class will have typed correctly.

Additionally, the compiler will catch the spelling and inappropriate capitalization mistakes in the program (Plamauer, & Langer, 2017).

Leaning this programming language will take time and experience. However, the memorizing of this programming language will be easy. Every block will have a similar structure, which will be standard for the developer who will continuously create new blocks. Several methods will be available for shorting and encapsulating data such as inheritance, abstraction, etc. The index of the array will start from 1 instead of zero. Thus it will have less chance for overflowing the stack. It will be easy to solve complex problems with the help of the Radiohead programming language (Sebesta, 2016).

This programming language will reliable in terms of error miss from both the compiler and developer end. Therefore it will reduce the chance of fatal errors. Many will be encouraged by using the Radiohead programming language. The programmers can make a wide range of applications, mobile app, software related to scientific computation. It will be a safe and trustworthy language for the experienced developer. Radiohead will be more reliable than other programming languages such as Java, C++, Python, etc., and the structure of this language will be well planned (Sheikh, 2016).

References

• Al-hassy, M., Carette, J., & Kahl, W. (2019, October). A language feature to unbundle data at will (short paper). In Proceedings of the 18th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (pp. 14-19).
• Amy, M., Roetteler, M., & Svore, K. M. (2017, July). Verified compilation of space-efficient reversible circuits. In International Conference on Computer Aided Verification (pp. 3- 21). Springer, Cham.
• Baxter, J., (2017). An Approach to verification of Safety-Critical Java Virtual Machines with Ahead-of-time compilation. Technical Report. The University of York.
• Cservenka, M. H. (2018). Design and implementation of dynamic memory management in a reversible object-oriented programming language. arXiv preprint arXiv:1804.05097.
• Duhoux, B., Mens, K., & Dumas, B. (2019, July). Implementation of a feature-based context- oriented programming language. In Proceedings of the Workshop on Context-oriented Programming (pp. 9-16).
• Ezenwoye, O. (2018, October). What language?-The choice of an introductory programming language. In 2018 IEEE Frontiers in Education Conference (FIE) (pp. 1-8). IEEE.
• Guatto, A., Westrick, S., Raghunathan, R., Acar, U., & Fluet, M. (2018). Hierarchical memory management for the mutable state. ACM SIGPLAN Notices, 53(1), 81-93.
• Hunt, J. J., & Sinyavskiy, O. (2016). U.S. Patent No. 9,330,356. Washington, DC: U.S. Patent and Trademark Office.

• Huo, X., Li, M., & Zhou, Z. H. (2016, July). Learning unified features from natural and programming languages for locating buggy source code. In IJCAI (pp. 1606-1612).
• Jones, R., Hosking, A., & Moss, E. (2016). The garbage collection handbook: the art of automatic memory management. CRC Press.
• Kannan, S., Gavrilovska, A., Gupta, V., & Schwan, K. (2017, June). Heteroos: Os design for heterogeneous memory management in the datacenter. In Proceedings of the 44th Annual International Symposium on Computer Architecture (pp. 521-534).
• Kiselyov, O. (2018). Reconciling abstraction with high performance: A metaocaml approach. Foundations and Trends® in Programming Languages, 5(1), 1-101.
• Plamauer, S., & Langer, M. (2017, April). Evaluation of micropython as application layer programming language on cubesats. In ARCS 2017; 30th International Conference on Architecture of Computing Systems (pp. 1-9). VDE.
• Raghunathan, R., Muller, S. K., Acar, U. A., & Blelloch, G. (2016). Hierarchical memory management for parallel programs. ACM SIGPLAN Notices, 51(9), 392-406.
• Sebesta, R. W. (2016). Concepts of programming languages. Pearson Education, India. Sestoft, P. (2017). Programming language concepts. Springer.
• Sheikh, G. S. (2016). A qualitative study of major programming languages: teaching programming languages to computer science students. Journal of Information & Communication Technology (JICT), 10(1), 11.