Which of the following is not a true statement about high-level and low-level programming languages?

Machine Language

Machine language is the language understood by a computer. It is very difficult to understand, but it is the only thing that the computer can work with. All programs and programming languages eventually generate or run programs in machine language. Machine language is made up of instructions and data that are all binary numbers. Machine language is normally displayed in hexadecimal form so that it is a little bit easier to read. Assembly language is almost the same as machine language, except that the instructions, variables and addresses have names instead of just hex numbers.

6.4 AsmL

The Abstract State Machine Language [AsmL] [37] is a fusion of the Abstract State Machine paradigm and the .NET language runtime system. AsmL can be integrated with any .NET language: AsmL models can perform callouts, and AsmL models can be called and referred to from other .NET languages. AsmL supports meta-modeling that allows a programmatic exploration of the non-determinism in the model. This allows one to realize various state exploration algorithms for AsmL models, including explicit state model-checking, and in particular test generation and test evaluation.

AsmL. The AsmL tool environment [37] generates a FSM by exploring the state space of the AsmL model by explicit-state model-checking techniques. Starting at the initial state, enabled actions are fired, leading to a set of successor states, from where the exploration is continued. An action is enabled if the precondition of the method is true in the current state. From the FSM, test cases [i.e., call sequences] can be generated to provide conformance testing between the model and an implementation, where the implementation can be written in any of the .NET languages. To enable this, the implementation assemblies are rewritten on the intermediate code level by inserting callbacks monitored methods to the runtime verification engine. Each time a monitored method is called, its parameters and output result are propagated to the conformance test manager. On each of the currently possible model states, the according model method will be called. The resulting states of those calls constitute the set of next model states. If this set becomes empty, the conformance test fails.

Next, we select a representative tool of the pre/post notation category, and apply it on our running example.

6.4.7 Interpreting Machine Language Code

To interpret machine language, one must decipher the fields of each 32-bit instruction word. Different instructions use different formats, but all formats share a 7-bit opcode field. Thus, the best place to begin is to look at the opcode to determine if it is an R-, I-, S/B-, or U/J-type instruction.

Example 6.6

Translating Machine Language to Assembly Language

Translate the following machine language code into assembly language.

 0x41FE83B3

 0xFDA48293

Assembly Language

Today programmers rarely write programs in machine language. Instead, they use the clearer assembly languages or high-level languages. These languages are partly responsible for the current widespread use of computers.

Programmers, burdened by machine language programming, began using English-like abbreviations for the various machine language instructions. Called mnemonics [memory aids], these abbreviations related to the action to be taken and made more sense to the programmer. For example, instead of writing “+ 20” to represent addition, a programmer might write the mnemonic “ADD”; “SUB” might be used for subtraction, “DIV” for division, and the like. Even the storage locations were given names. If location 92 contained a total, it might be referred to as “TOTAL” or “SUM” instead of 92. The resulting programs were much easier to understand and modify. For example, in a payroll program that subtracts total deductions from gross pay to calculate net pay, the following assembly language instructions might appear:

Unfortunately, computers could not understand these programs, so the mnemonics still had to be translated into machine language for processing. An aristocracy arose in the programming profession. The “upper class” consisted of programmers who wrote programs using the English-like mnemonics. The “commoners,” called assemblers, then took these programs and manually translated them into machine language, a rather mechanical job. In the 1950s, programmers realized that this translation could be performed more quickly and accurately by computers than by people, and so the first assembler program, or translator program, was written [Figure 9-1]. The program of instructions written in assembly language is known as the source program; an assembler program translates it into a machine language program, called an object program.

Programs could be written faster with assembly language than with machine language, although they still had to be translated into machine language before they could be executed [see Figure 9-2]. The work involved in translation was more than justified by the resulting increased programming speed and fewer errors.

Assembly language programs are also machine dependent and not portable. Programmers must write large numbers of instructions to accomplish even simple chores, and the programs still appear to be in computerese [Figure 9-3].

Perhaps the major use of assembly languages today is in the writing of operating systems—the programs that control the hardware and make it more accessible to computer users [see Chapter 12].

16.1 Introduction

When dealing with language, [machine] learning can take many different faces, of which the most important are those concerned with learning formal languages and grammars from data. Questions in this context have been at the intersection of the fields of inductive inference and computational linguistics for the past 50 years. To go back to the pioneering work, Chomsky [1955] and Solomonoff [1964] were interested, for very different reasons, in systems or programs that could deduce a language when presented information about it.

Gold [1967] proposed a little later a unifying paradigm called identification in the limit, and the term of grammatical inference seems to have appeared in Horning's [1969] PhD thesis.

Out of the field of linguistics, researchers and engineers dealing with pattern recognition, under the impulsion of Fu [1974], invented algorithms and studied subclasses of languages and grammars from the point of view of what could or could not be learned [Fu and Booth, 1975].

Researchers in machine learning tackled related problems [the most famous being that of inferring a deterministic finite automaton, given examples and counter-examples of strings]. Angluin [1981, 1987] introduced the important setting of active learning, or learning from queries, whereas Pitt and Warmuth [1993] and Pitt [1989] gave several complexity inspired results, exposing the hardness of the different learning problems.

In more applied areas, such as computational biology, researchers also worked on learning grammars or automata from strings, e.g., Brazma et al. [1998]. Similarly, stemming from computational linguistics, one can point out the work relating language learning with more complex grammatical formalisms [Kanazawa, 1998], the more statistical approaches based on building language models, or the different systems introduced to automatically build grammars from sentences [Adriaans, 1992; van Zaanen, 2000]. Surveys of related work in specific fields can be found in Sakakibara [1997], de la Higuera [2005] and Wolff [2006].

When considering the history of formal learning theory, several trends can be identified. From “intuitive” approaches described in early research, more fundamental ideas arose. Based on these ideas and a wider availability of data, more research was directed into applied language learning. Recently, there has been a trend asking for more theoretically founded proofs in the applied area, mainly due to the increasing size of the problems and the importance of having guarantees over the results. These trends have led to the highly interdisciplinary character of formal language learning. Aspects of natural language learning [as an application arena], machine learning, and information theory can all be found here.

When attempting to find the common features of work in the field of language learning, one should at least consider two dimensions. Learning takes place in a setting. Issues in this dimension are properties of training data, such as positive/negative instances, amount, or noise levels, but also the measure of success. The other dimension deals with paradigms with respect to generalization over the training data. The goal of language learning is to find the language that is used to generate the training data. This language is typically more general than the training data, requiring a generalization approach.

This chapter is organized along the learning setting and paradigms dimensions. Firstly, we will look at different learning settings and their parameters. Secondly, different learning paradigms are discussed, followed by a conclusion.

8.2.3 Communicating with a computer: Programming languages

Programming languages provide the link between human thought processes and the binary words of machine language that control computer actions, in other words, instructions written by a programmer that the computer can execute. A computer chip understands machine language only, that is, the language of 0’s and 1’s. Programming in machine language is incredibly slow and easily leads to errors. Assembly languages were developed that express elementary computer operations as mnemonics instead of numeric instructions. For example, to add two numbers, the instruction in assembly language is ADD. Even though programming in assembly language is time consuming, assembly language programs can be very efficient and should be used especially in applications where speed, access to all functions on board, and size of executable code are important. A program called an assembler is used to convert the application program written in assembly language to machine language. Although assembly language is much easier to use since the mnemonics make it immediately clear what is meant by a certain instruction, it must be pointed out that assembly language is coupled to the specific microprocessor. This is not the case for higher-level languages. Higher languages such as C/C ++, JAVA, and scripting languages like Python, were developed to reduce programming time, which usually is the largest block of time consumed in developing new software. Even though such programs are not as efficient as programs written in assembly language, the savings in product development time when using a language such as C has reduced the use of assembly language programming to special situations where speed and access to all a computer's features is important. A compiler is used to convert a C program into the machine language of a particular type of microprocessor. A high-level language such as C is frequently used even in software for 8-bit controllers, and C ++ and JAVA are often used in used in the design of software for 16-, 32-, and 64-bit microcontrollers.

Fig. 8.1 illustrates the translation of human thought to machine language by use of programming languages.

Single statements in a higher-level language, which is close to human thought expressions, can produce hundreds of machine instructions, whereas a single statement in the lower-level assembly language, whose symbolic code more closely resembles machine code, generally produces only one instruction.

Fig. 8.2 shows how a 16-bit processor would execute a simple 16-bit program to add the numbers in memory locations X, Y, and Z and store the sum in memory location D. The first column shows the binary instructions in machine language. Symbolic instructions in assembly language, which have a nearly one-to-one correspondence with the machine language instructions, are shown in the next column. They are quite mnemonic and should be read as “Load the number at location X into the accumulator register; add the number at location Y to the number in the accumulator register; add the number at location Z to the number in the accumulator register; store the number in the accumulator register at location D.” The accumulator register in a microcontroller is a special register where most of the arithmetic operations are performed. This series of assembly language statements, therefore, accomplishes the desired result. This sequence of assembly statements would be input to the assembler program that would translate them into the corresponding machine language [first column] needed by the computer. After assembly, the machine language program would be loaded into the machine and the program executed. Because programming in assembly language involves many more details and low-level details relating to the structure of the microcomputer, higher-level languages have been developed. FORTRAN [FOR-mula TRANslator] was one of the earlier and most widely used programming languages and employs algebraic symbols and formulas as program statements. Thus the familiar algebraic expression for adding numbers becomes a FORTRAN instruction; for example, the last column in Fig. 8.2 is the FORTRAN statement for adding the three numbers and is compiled into the set of corresponding machine language instructions of the first column.

1.1 History of IoT

IoT has evolved when the major language was not famous on those days such as machine language, commodity analysis, etc. Nowadays automation, control system, and wireless sensor networks are connected to Internet and help to make us easier to do work.

Kevin Ashton in 1999 was the first who coined the term IoT, i.e., “Internet of Things.” But in earlier the concept of IoT was proposed in Carnegie Mellon University in 1982 that works on the concept of network smart devices.

Nowadays the technology is increasing day by day like CISCO is introducing a new technology and in future the technology will replace every human work with this technology [Rastogi, Chaturvedi, Satya, Arora, Yadav et al., 2018].

1.1.1 Early Automation Systems

In the 1960s and 1970s, the minicomputer served as the predecessor to the current day PLC; the minicomputer was programmed in assembly or machine language and interfaced directly with plant devices. The minicomputer was a general purpose digital computer, capable of being programmed in a few different languages, but it was primarily used for automation systems in plants. I have programmed many such systems, mostly in machine language, but some even used FORTRAN and ALGOL!

The PLC first came into being around 1971, designed and built by Gould Modicon, and was intended to replace the traditional relay ladder logic electrical circuitry. The programming language was developed to mimic the relay logic of the electrical circuits, with ‘power’ and ‘return’ rails on the left and right, respectively. By around 1977, Allen–Bradley introduced their first major PLC, by which time the idea of a programmable controller had become quite widely accepted. The minicomputer was being replaced with these new programmable devices, primarily because the language was already familiar to the electricians, and hence learning to ‘program the circuits’ was pretty straightforward. These controllers were also digital computers but were designed to interface to the basic field signals we still use today: discrete inputs and outputs, and analog inputs and outputs.

The PLC hardware and software continued to develop and evolve until the programming became much more than the original electrical circuitry that they were meant to replace. With the introduction of Microsoft Windows and the Graphical User Interface [GUI], more intuitive and graphical programming became possible. Today, the PLC programmer expects an easy to use yet feature rich programming environment.

Machine Language Instructions

The various operations a computer can interpret and perform are called its machine language instructions. Most computers have instructions that can input data from outside the computer into the computer's main storage, output data from main storage, perform simple arithmetic calculations, move data between main storage locations, edit data, perform comparisons, and handle many other functions.

The processor reads the instructions in a computer program and performs these instructions one at a time in the proper sequence. Machine language instruction formats vary widely among the different types of computers. For example, large-scale scientific computers, such as those used by the National Aeronautics and Space Administration [NASA] in the space shuttle program, generally have instructions that perform precise mathematical calculations at great speed. Data processing computers used by businesses generally have instructions that can manipulate and edit large amounts of information efficiently.

Some computers have instructions that reference only a single piece of data; these are called single operand instructions. Other computers have instructions that specify two or more data items; these are called multiple operand instructions. The more operands per instruction, the more powerful the instruction.

For example, to calculate the sum of two numbers, one stored at location 1000 and four bytes long and another stored at location 2000 and three bytes long, a machine language instruction like

might be used. By convention, such machines generally add the two numbers together and place the result in the first field [in this case, addresses 1000 through 1003]. This, of course, destroys the value that was there initially. For readability we will use an English word to represent the operation and decimal numbers to represent the operands; genuine machine languages use binary ones and zeros.

A machine that has only single operand instructions would perform the same addition by a sequence of instructions that might look like

The LOAD instruction loads a special register [a temporary storage device in the ALU, often called an accumulator] with the 4-byte number starting at location 1000. The ADD instruction adds to the contents of the accumulator the 3-byte number beginning at location 2000. Finally, the STORE instruction stores the results of the previous calculation from the accumulator into the 4-byte field beginning at location 1000. Thus, computers with single operand instructions generally require many more instructions to accomplish the same tasks than would be required by computers with multiple operand instructions. As the price of computers continues to decline, their machine languages are tending toward multiple operand instruction sets.

Machine language programming is tedious and susceptible to error. As we will see in our discussion of programming languages in Chapter 9, most programming today is actually done in high-level languages that use English words and common mathematical notations.