System type is
a set of values that share a common structure, operation and other
characteristics. One type of system is a detail how type is set value. Type
safety is prevention some classes of programming errors, desired property of a
programming language. Many of the
recently published standards for safety critical software require the use of
strongly typed programming language. Through the years developed a wide variety
of systems and found their way to commercial success language. A security-typed
language provides overall display groups of data security not only in certain
areas but during the period of calculation. To the extent that a system can be
described if a program or a set of communication programs written in a security
typed language, the architectural nature of the type of system increases this
protection the whole system.
The main
purpose of a type of system is the occurrence of errors during execution
prevention the implementation of a program. This casual statement motivates the
study of type systems but requires clarification. The accuracy depends first of
all on the previously subtle question of what an execution error, which we will
discuss in detail. Although it is controlled, the absence errors implementation
is a little feature. When such a property holds for all programs running can be
expressed in a programming language, we say that the language is the type
sound. It turns out that it takes a fair amount of overhaul false and distracts
to prevent claims of healing type for programming languages. As a result,
sorting, characterization, and the study of these types have emerged as a
formal discipline system.
There
are the basic properties expect from each type of system:
·
Type system must be verifiable decidable an algorithm should be called
type checking algorithm that can ensure that a program is well behaved. The
purpose of a type of system is not only to state programmer intent but to
actively secure the performance mistakes before they happen. Random formal
specifications have not properties.
·
These types of systems must be transparent. A programmer should be
able to easily predict or program type checking. If either type of check the
cause of the malfunction should be clear. Auto testimony that does not have
these properties.
·
Type system should be executed such as statements statically
checked as possible and otherwise controlled dynamic. The relationship between
type statements and related programs should be regularly monitored. Comments program
and conventions do not have these properties.
Typed and untyped languages
A program
variable can take on a range of values during the execution of a program. An
upper bound by such a set is a kind of variable. Language where the variables
can be given non-trivial type is called typed language.
Languages that
do not limit the scope of the variable are called untyped language. That is the
kind of not only a universal type that contains all values. In these languages,
operation can be applied to inappropriate arguments. The result can be an
arbitrary fixed value, error, exception or an unspecified effect.
Properties of type systems:
Type, as normally is used in programming languages, with the
characteristics of pragmatic to distinguish it from other types of annotation
software. In general, about annotations the behaviour of programs can range
from informal comments to formal specifications are subject to claims proving.
Types sit in the middle of the spectrum: they are more accurate than the
comments of the program, mechanizable and easier than formal specifications.
Here are the basic properties expect from each type of system:
·
The type must be verifiable decidable: there must be an algorithm
called Type-checking algorithm that can ensure that the program is well-behaved.
The aim kind of system is not only to state programmer intent, but actively to
make errors before they happen. Arbitrary formal specification does not
properties.
·
Type system must be transparent: the programmer should be able to
easily predict if the program is type-check. If you fail type-check, the reason
for failure it should be obvious. Automatic theorem proving any possessions.
·
Type system must be executable: type declarations must be checked passively
as possible and otherwise dynamic control. The changes between typing declarations
and related programs should be routinely checked. Programs and conventions do
not have such properties.
Comments
Post a Comment
any suggestion on my side