Descriptions are used to interpret each of the identifiers; they do not need to be accompanied by an allocation of memory associated with the identifier. Descriptions look like

spec-descriptions opt spec-list opt ​​;

function-definition

specification-links

Descriptors in a descriptor-list (§R.8) contain the identifiers being described. A specification-description construct may only be absent from a function definition (§R.8.3) or from a function description. The declarative list can be empty only when declaring a class (§R.9) or an enumeration (§R.7.2), i.e. when the description-specification is a class-specification or an enumeration-specification. The description-asm construct is explained in §R.7.3, and the specification-links in §R.7.4. Description occurs within a defined scope (§R.3.2), the scope rules are given in §R.10.4.

R.7.1 Specifications

The following specifications can be used in the description:

specification-description:

memory-class-spec

type-spec

type-template-specification

specifications-descriptions:

specification-descriptions opt specification-descriptions

The longest sequence of specification-description constructs, which is possibly a type name, forms a specification-description construct in the description. The sequence must be consistent, which is explained below. For example,

static PC; // error: no name

Here the declaration of static Pc is illegal because no static variable name of type Pc is specified. To have type variable int with the name Pc, it is necessary to specify an int type-specification to indicate that the name Pc of the typedef is being (re)defined, rather than simply Pc being one of the elements of a sequence of description-specification constructs, e.g.

void f(const Pc); // void f(char* const)

void g(const int Pc); // void g(const int)

We point out that since signed, unsigned, long and short are treated as int by default, the name-typedef construction that appears after one of the listed type specifications must specify the name to be (re)defined, e.g.

void h(unsigned Pc); // void h(unsigned int)

void k(unsigned int Pc); // void k(unsigned int)

R.7.1.1 Memory class specifications

Memory class specifications could be:

memory-class-spec:

The auto and register specifications can only be used for object names that are described in a block (§R.6.3) or for formal parameters (§R.8.3). The auto specification is almost always redundant and infrequently used, so auto is used to explicitly separate a declaration statement from an expression statement (§R.6.2).

The register description is an auto description, which tells the translator that the described variables will be used quite intensively. The hint can be ignored, and in many implementations it is ignored when the address of a variable is taken.

An object description is considered a definition unless it contains an extern and initialization specification (§R.3.1).

The definition causes the appropriate size of memory to be allocated and the appropriate initialization to be performed (§R.8.4).

The static and extern specifications can only apply to object or function names or to anonymous unions. Descriptions of functions with a static specification or formal parameters with a static or extern specification are not allowed inside a block. Static members classes are described in §R.9.4. The extern specification is not valid for class members.

A name with the static specification is subject to internal linkage. Objects declared as const are subject to internal linkage unless they have been declared with external linkage. A name with the extern specification is subject to external linkage unless it has previously been declared with internal linkage. A file-scoped name without a memory-class-spec is subject to external linkage unless it has previously been declared with internal linkage or a const specification. In terms of binding for non-member functions, the inline specification is equivalent to static (§R.3.3). For a single name, all of its binding specifications must agree. For example,

static char* f(); // f() has internal binding

char* f() // f() is still internal

char* g(); // g() has outer binding

static char* g() // error: binding contradiction

static int a; // `a" has internal binding

int a; // error: second definition

static int b; // `b" has internal binding

extern int b; // `b" is still internal

int c; // `c" has outer linkage

static int c; // error: binding contradiction

extern int d; // `d" has outer binding

static int d; // error: binding contradiction

The name of an undefined class can be used in the extern declaration. However, such a description cannot be used before the class has been defined, for example,

g(a); // error: S is undefined

f(); // error: S is undefined

R.7.1.2 Function specifications

Some specifications can only be used to describe functions.

The inline specification tells the translator to substitute the function body instead of the usual implementation of the function call. The hint may be ignored. In the case of non-member functions, the inline specification additionally establishes internal binding for the function (§R.3.3). A function (§R.5.2.2, §R.8.2.5) defined in a class declaration has an inline specification by default.

A member function with an inline specification must have exactly the same definition in every translation unit in which it appears.

A member function does not need to be explicitly declared with an inline specification in the class declaration for it to be treated as a substitution. If there was no inline specification, the binding will be external unless a definition with an inline specification appears before the first function call.

inline int g(); // X::g() has internal binding

int i = p-›f(); // now X::f() is outer bound

inline int X::f() // error: call before definition

inline int X::h() // X::h() is now internally bound

The virtual specification may only be used in declarations of non-static member functions in class declarations (see §R.10.2).

R.7.1.3 Typedef specification

Typedef declarations specify identifiers that can later be used to denote basic or derived types. A typedef specification is not allowed in a function definition (§R.8.3).

Within the scope (§R.3.2) of a typedef declaration, any identifier appearing in part of any of the descriptors becomes syntactically equivalent to a function word and denotes the type associated with that identifier, as described in §R.8. Thus, typedef-name is a synonym for another type. Unlike a class declaration (§R.9.1), typename does not add a new type. For example, after describing

designs

are legal descriptions, distance is of type int, and metricp is of type "pointer to int".

Using a typedef, you can redefine a name so that it again denotes a type that was already referred to, even in the scope in which the type was originally declared, for example,

typedef struct s (/*… */) s;

An unnamed class that is defined in a typedef takes as its name the name used in the typedef, e.g.

typedef struct (/*… */) S; // structure name became S

A typedef cannot be used to redefine the name of a type declared in the same scope to denote a different type, e.g.

typedef int complex; // error: override

Likewise, you cannot define a class with the name of a type defined in the same scope so that it denotes another type, e.g.

class complex (/*… */); // error: override

A typedef that denotes a class is a class-name (§R.9.1). The synonym cannot be used after the following prefixes: class, struct and union, as well as in the names of constructors and destructors in the description of the class itself, for example,

S a = T(); // Fine

R.7.1.4 Type template specification

A type template specification is used to specify a family of types or functions (see §R.14).

R.7.1.5 Friend Specification

The friend specification is used to specify access to class members (see §R.11.4).

R.7.1.6 Type specification

Type specifications include:

type-spec:

simple-type-name

class-spec

specification-enumerations

complex-type-specification

When declaring an object, the const and volatile service words can be added to any legal type-specification. In all other cases, no more than one type specification may be present in the description. An object with const specification can be initialized, but its value must not change later. An object with a const specification, unless it has been explicitly declared extern, is not subject to external linkage and must be initialized (§R.8.4, §R.12.1). A const integer initialized with a constant expression may be used in a constant expression (§R.5.19). Every element of an array with a const specification has the same specification, and every non-static non-function member of a class object with a const specification is itself considered const (§R.9.3.1). An object of a type without a constructor or destructor that has a const specification can be placed in read-only memory. An attempt to write to any part of such an object will either lead to a special address situation, or will pass without a trace, as if the object did not have a const specification.

There is no implementation-independent explanation for objects with the volatile specification. It serves as a hint to the translator to avoid too much optimization associated with this object, since the value of the object may change in ways hidden from the translator. Each element of an array with the volatile specification has the same specification, and each non-static non-function member of a class object with the volatile specification is itself considered volatile (§R.9.3.1).

If the type-spec is not present in the declaration, it is assumed to be specified as int.

simple-type-name:

full-class-name

qualified-type-name

You cannot specify more than one long or short function word with int. They can also be used individually, in which case the type is considered to be int. The service word long may appear together with double. You cannot specify more than one signed or unsigned function word with char, short, int, or long. They can also be used individually, in which case the type is considered to be int. The signed specification indicates that char objects and bit fields are signed; for other integer types this specification is redundant.

The class-specification and enumeration-specification constructs are defined in §R.9 and §R.7.2, respectively.

complex-type-specification:

class-word class-name

class-identifier function-word

class-word:

If an identifier is given, the complex-type-specification describes it as a class-name (see §R.9.1).

If a name is defined that is described by the union specification, then it must be defined as a union. If a name is defined that is described by the class specification, then it must be defined using the class or struct specification. If a name is defined that is described by the struct specification, it must be defined by the class or struct specification. Names of nested types (§R.9.7) must be qualified by the name of the enclosing class:

qualified-type-name:

class-name:: qualified-type-name

full class-name:

qualified-class-name

:: qualified-class-name

qualified-class-name:

class-name:: qualified-class-name

The name qualified by class-name must be a type defined in that class or in a base class of that class. As usual, a name declared in a derived class makes members with that name from base classes invisible (see §R.3.2).

R.7.2 Enumeration description

An enumeration is a separate integer type (§R.3.6.1) with named constants. Its name in its scope becomes an enumeration-name construct, i.e. serves as a reserved word.

enum-name:

specification-enumerations:

enum identifier opt ( enum-list )

enum-list:

enum-item

enumeration-list, enumeration-item

enum-item:

identifier = constant expression

All identifiers in an enumeration list are considered to be declared constants and may appear wherever constants are required. If there were no enumeration elements with =, then the values ​​of the constants start from zero and sequentially increase by one as they move in the list from left to right. If an enumeration element is encountered with =, then its identifier takes on the given value, and subsequent identifiers without an initialization part will receive increasing values, starting from the given one. The value of an enumeration element must be of type int or a value that can be cast to int using standard integer conversions (§R.4.1).

The names of enumeration elements must be different from the names of ordinary variables and other enumeration elements of the same scope. The values ​​of enumeration elements do not have to be different from each other. An enumeration element is considered to be described from the moment its identifier or initializing value (if any) appears. For example, in the definitions

the values ​​of a, c, and d are given as 0, b and e as 1, and f as 3.

Every enum is an integral type, which is distinct from all other integral types. The type of an enumeration element is a given enumeration. The value of an enumeration element or an object of an enumeration type is converted to an integer using standard integer conversions (§R.4.1). For example, in the following snippet:

enum color (red, yellow, green=20, blue);

color is defined as an integer type describing different colors, col is defined as an object of that type, and cp is defined as a pointer to an object of that type. Possible values ​​for an object of type color are red, yellow, green, blue. These values ​​can be converted to the integer values ​​0, 1, 20 and 21. Since each enum is a separate type, an object of type color can only be assigned values ​​of type color, e.g.

color c = 1; // error: type mismatch

// no conversion from int to color

int i = yellow; // ok: yellow is converted to int with value 1

// standard integer conversion

See also §R.18.3.

Enumeration members defined in a class (§R.9) are within the scope of that class and can be accessed from outside that class's member functions only by explicit qualification by the class name (§R.5.1). The name of the enum type itself is local to that class (§R.9.7), e.g.

description-list:

description-list description

The required binding is specified using a string literal. Its purpose is implementation-defined. But all implementations must provide binding to a function in the C language ("C") and a function in the C++ language ("C++"). The default binding is set to "C++", for example,

complex sqrt(complex); // default binding to C++

double sqrt(double); // binding to C

Communication specifications can be nested. The communication specification does not specify a scope. A link-specification can only occur in the file scope (§R.3.2). The binding specification for a class refers to the objects described in it and non-member functions. A binding specification that applies to a function also applies to all objects and functions described in it. A connection description containing a string unknown to the implementation is considered incorrect.

If a function has more than one connection specification, then they must be consistent, i.e. set the same literal string. A function description without a link specification must not precede the first link specification for that function. A function may be declared without specifying a binding specification even after the binding specification has been explicitly specified, but a binding explicitly specified in an earlier declaration will not be removed by such a function declaration.

Of the set of overloaded functions (§R.13) with a given name, at most one can have a C binding, see §R.7.4.

Binding can be set for objects, for example:

int _flsbuf(unsigned,_iobuf*);

When a communication specification is specified, functions and objects can be described as static within ( ). For such functions or objects, the bind command is ignored. Otherwise, the function declared when specifying the link is treated as if it were explicitly declared as extern, for example, the second description below is erroneous (§R.7.1.1):

static double f(); // error

An object described within a construct

is still considered definite and not merely described.

Linking C++ objects to objects defined in other languages, as well as reverse binding, is language and implementation dependent. Such linking is only possible if the algorithms for placing objects in memory are sufficiently similar for the two languages.

If a programming language name is used to specify a relationship in a literal string from a relationship specification, it is recommended that the spelling of that name be copied from the document defining given language eg Ada (not ADA) and Fortran (not FORTRAN).

department 304

Laboratory work No. 2

in the subject "Programming"

Completed by a student 315 gr.

Startseva A.V.

I checked assoc. department 304

Bakumenko N.S.

________________________

Subject:"SpecificationWITH++"

Goal of the work: Learn to write a description of the main characteristics of a program or subroutine. The specification always includes the following characteristics: statement of the problem that is solved by a given program or subroutine, description of the initial data, description of the results, description of special situations.

Condition:

9.59. A proposal has been given. Determine the number of letters "O" in him.

9.101.The word is given. Swap its third and last letters.

9.155.A word contains only two identical letters. Find them.

Performance:

Name:Vvod

Description: The function reads a character value from the console.

Initial data:

Name: 1)symbol; 2) S;

Description: 1) variable to which is assigned specific value(some symbol); 2) a given sentence or word - a subroutine parameter, transmitted from the main program in the form of a set of characters.

Type and Range: 1)Char, any characters; 2) string, any symbols

Result: The function reads data entered by the user from the keyboard.

Exceptional Descriptions:

Description: 1) data of the wrong type has been entered 2) more data has been entered than is necessary for the program

Treatment: 1), 2) - a message will be displayed stating that errors were detected while building the program.

Name:Vuvod

Description: The function outputs an integer, character value, or string from the console.

Initial data:

Name: 1) n 2) s; 3) h.

Description: n, s, h. - variables to which the result of the function (specified task) is assigned. 1) The subroutine returns one value - the number of letters "O" in a given sentence. 2) The subroutine returns an array of type char, in which the second and last elements are swapped (a word in which the third and last letters are swapped). 3) The subroutine returns one value - a letter , which is repeated in the word.

TypeAndrange: 1) int; 2) string; 3) char.

Result: the function displays the result of the program, that is, displays the variables n, s, h.

Name: Func

Description: Defines the number of letters "O" in a given sentence.

Initial data:

Name: 1) S; 2) symbol, 3) n

Description: 1) The source array (a given sentence) is a parameter of the subroutine, transferred from the main program in the form of a set of characters. 2) a variable to which the symbol “o” is assigned

Type and Range: 1) string, any characters. 2) Char, o symbol.

Result:

Name: cout

Description: The subroutine prints the value of variable n.

Type and range Int

Exceptional Descriptions

Description: the sentence does not contain the letter o.

Treatment: a message is displayed that the sentence does not contain the letter o.

Name: Func1

Description: The function swaps the third and last letters of a user-specified word.

Initial data:

Name: 1) S; 2) l, k 3) temp; 4)s

Description: 1) Source array (specified word) – subroutine parameter, transferred from the main program in the form of a set of characters. 2) a variable to which the value of the second element of the array is assigned. 2) variables that are assigned the indices of the third and last letter of a given word. 3) a variable that is first assigned the value of the second element of the array, then reassigned while the program is running.

Type and Range: 1) string, any symbols; 2) int 3) int.

Result:

Name: cout

Description: The subroutine prints the value of the variable s

Type and Range: string.

Exceptional Descriptions

Description: 1) the array is not specified correctly, 2) the indexes are set to the wrong type.

Treatment: 1), 2) - a message will be displayed stating that errors were detected while building the program.

Name: Func2

Description: The function finds two identical letters contained in a given word.

Initial data:

Name: 1) S; 2) h.

Description: 1) Source array (specified word) – subroutine parameter, transferred from the main program in the form of a set of characters.

Type and Range: 1) char

Result:

Name: cout

Description: The subroutine prints the value of the variable h.

Type and Range: char.

Exceptional situations:

Description: 1) the word does not contain identical letters 2) the word consists of all identical letters 3) the array is not specified correctly

Treatment: 1), 2) - the number “-1” is displayed. 3) a message will be displayed stating that errors were detected while building the program.

Common Language Specification CLS

As is known, in different languages programming, the same program constructs are expressed in their own unique, language-specific way. For example, in C#, string concatenation is indicated by using the plus sign (+), while in VB, the ampersand (&) is typically used for this purpose. Even if the same programming idiom is expressed in two different languages ​​(for example, a function that does not return a value), the likelihood is very high that the syntax will look very different.

As has already been shown, such small variations in syntax for the .NET runtime are insignificant due to the fact that the corresponding compilers (in in this case- csc.exe and vbc.exe) generate a similar set of CIL instructions. However, languages ​​may also differ in their overall level of functionality. For example, in some .NET language there may or may not be keyword to represent unsigned data, and whether pointer types are supported or not. Because of all the possible variations, it would be great to have some basic requirements that all .NET-supporting languages ​​would have to meet.

CLS (Common Language Specification - common specification for programming languages) is precisely a set of rules that describe in detail the minimum and complete set functionality, which each individual .NET compiler must necessarily support in order to generate such program code, which could be served by the CLR and which at the same time could be accessed in a uniform way by all languages ​​targeting the .NET platform. In many ways, CLS can be considered simply a subset of all the functionality defined in CTS.

Ultimately, the CLS is a set of rules that compiler creators must adhere to if they want their products to function smoothly in the .NET world. Each of these rules has a simple name (for example, "CLS Rule number 6") and describes how it applies to those who write compilers and those who (in any way) will interact with them. The most important thing about the CLS is rule 1, saying that CLS rules apply only to those parts of a type that are made accessible outside the assembly in which they are defined .

What can (and should) be concluded from this rule is that all other rules in the CLS do not apply to the logic used to build the internal working parts of a .NET type. The only aspects of a type that must comply with CLS are themselves definitions of members(i.e. naming conventions, parameters and return types). Within the member implementation logic, any number of techniques that are not consistent with CLS can be used, since this will not play any role for the outside world.

For example, take case sensitivity. IL is case sensitive. Developers who write in case-sensitive languages ​​make extensive use of the flexibility that this case sensitivity provides when choosing variable names. However, the language Visual Basic 2010 is not case sensitive. The CLS specification gets around this problem by specifying that any CLS-compliant code must not include any name pairs that differ only in case. This way, Visual Basic 2010 code can work with CLS-compliant code.

This example illustrates that CLS works in two ways.

Lubricants began to be used long before our era. And if earlier vegetable fats and fats of animal origin were used, then starting from the 60s of the last century they were replaced by petroleum products. After this, the active development and improvement of motor oils began, and about 70 years ago the first polymer viscosity modifiers appeared, thanks to which different classes and varieties soon appeared in motor oils that meet temperature conditions certain times of the year, and all-season types of lubricants have also appeared.

Since then, the composition and technical qualities of oils have undergone many changes, but their main purpose has remained unchanged. Motor oil is designed to cover moving parts with a thin but durable film, thereby protecting them from friction with each other.

Today, there are several oil classification systems that make it possible to divide lubricants according to their performance, technical characteristics, and purpose. Among the main generally accepted systems, one of the most famous is the API classification of motor oils. It was introduced in the late 50s of our century by the American Petroleum Institute, and the fundamental principle in it is the classification into two categories - S and C, that is, for gasoline and diesel engines, respectively.

S and C oil specifications

As noted above, the API system is divided into two main categories, but there is also a third designation for the quality of lubricants. Of these, each type is independent:

All these standards are designated by a two-letter index, for example, SN, SM, SH, SG, CF, CI, where the second value is an indicator of the level of performance characteristics. Moreover, the closer to the end of the Latin alphabet the letter in the designation is, the higher the API oil level. For example, a product designation such as API SL, SM or SN indicates superiority to API SF.

Gasoline engines: quality classes, their designations and interpretation

Group	Description
SN	SN lubricants differ from the SM specifications that preceded this category in that they contain much less phosphorus, which gives them additional energy-saving properties and makes SN compatible with the latest systems aimed at neutralizing exhaust gases. Class SN was approved in the fall of 2010 and is used in the engines of the most modern cars. It is worth noting that oils with API SN specification are similar in their characteristics to ACEA C2, C3, C4, so SN can successfully replace SM class lubricant.
S.M.	SM was first introduced in late 2004. This class is more common today than CN, because it is intended for modern gasoline engines, including multi-valve and turbocharged engines. Lubricants in this category were developed taking into account the improvement of engines, and therefore are designed to increase their environmental safety and be more wear-resistant. SM differs from the previous SL category in its greater resistance to oxidation and excellent protective properties against the formation of sludge and deposits, which certainly affects high quality lubricants. Two years after the release of SM, a category of oils for diesel engines was developed with the designation CJ4. SM specification products are intended for and designed specifically for vehicles manufactured since 2004.
SL	The SL class was developed shortly before the release of SM and SN. It is designed for car engines produced since 2001, and absolutely meets all modern standards and requirements, including high environmental friendliness and energy saving. SL are intended for modern engines, including multi-valve, turbocharged and engines adapted to run on lean fuel mixtures. The engines for which SJ category products are intended can also operate with lubricants from the SL group. Thanks to properties such as reduced volatility, SLs are distinguished by long-term retention of their properties, due to which the engine oil change interval is noticeably extended. Today, this category is valid and widely used by modern car owners.
S.J.	This class is also valid today. It was approved in November 1995, although the product was certified only a year later. Therefore, SJ category oils are used for cars with gasoline engines starting in 1996. They are successfully used in engines of passenger cars and sports cars, as well as in engines of minibuses and small trucks. SJ shows good specifications, including resistance to the formation of sediment and soot, as well as the ability to retain its properties at low temperatures. In terms of these properties, oils of the SJ category are very close to products of the SH class, and therefore are quite suitable for use in cases where the car manufacturer recommends the use of SH category oils for the car.
SH	This category was created in 1992 and is considered conditionally valid. Oils included in this group are used in car engines produced in 1996 and earlier. In terms of its qualities, this class is superior to oils of the SG category, because it was developed to replace it. Therefore, SH class oils are successfully used for cars in which SG is recommended.
S.G.	Class SG is intended for engines manufactured in 1193 and earlier. Oils in this category have excellent protection against soot and are resistant to oxidation and corrosion. SG oils meet all the requirements for motor oils intended for API CC diesel engines, which means SG can be used for cars in which the manufacturer recommends the use of categories SF and SF/CC, as well as SE and SE/CC.

Specification of oils for diesel engines

Among modern motor oil specifications, the most popular are CI and CF class oils. They are designed taking into account all the features of modern diesel engines and meet all standards.

C.I.

Category CI -4 approved in 2002. They are designed for various diesel engines, CI specification products are highly resistant to oxidation and contain dispersant additives. CIs are quite environmentally friendly compared to previous classes of oils. It is worth noting that from the general CI category there is another class - CI -4 PLUS. The improved CI -4Plus class was developed taking into account stringent requirements for oil volatility and its oxidation during elevated temperatures and soot formation.

CF

The CF specification was created for diesel engines with indirect injection. They are distinguished by a high content of various additives that prevent deposits on the pistons, and also protect against wear and corrosion of internal parts containing copper, for example, bearings. Class CF may be designated CF-4 and CF-2, which means motor oils intended for use in four-stroke and two-stroke (respectively) diesel engines. At the same time, CF-4 are designed for engines operating in accelerated mode, and CF-2 are ideal for engines that are constantly subject to increased loads.

API Classifications Video

Specification

Specification- (Late Lat. specificatio, from Lat. species - genus, species, variety and facio - do) can mean:

1. definition and list of specific features, refined classification of something;
2. an engineering term denoting a set of requirements and parameters that are satisfied by some technical object (for example, a bridge over a river satisfies such parameters as maximum total load weight, maximum axle load, maximum speed wind, etc.)

According to the definition given in Unified system design documentation (ESKD), specification- the main design document defining the composition of an assembly unit, complex, kit. The specification contains a detailed listing of the components and parts of any product, design, installation, etc., included in the assembly or working drawing.

According to the definition given in the Polytechnic Dictionary, specification- a document made in the form of a table that defines the composition of a product. Contains symbols components, their names and quantities.

Varieties

Specification, supplemented by prices for items and additional conditions(price, packaging, terms and conditions of delivery, details of the parties) may be an integral part of the supply agreement, or act as commercial offer. These types of specifications are formed in response to technical task(TOR) to the contract for the supply (manufacturing) of mechanisms, equipment, etc., or according to a questionnaire. The specification may contain a set of technical (and other) conditions (TS), but this set usually confirms the technical requirements for the technical specifications. The TK specification itself is not, but only a response to the TK according to the terms of delivery.

The invoice specification is part of the payment document.

Technical specification - specification of a technical device.

In information science and computer technology:

• Format specification file system(UDF, etc.)
• Programming language specifications and descriptions (CLI, etc.)

SMILES is a specification for an unambiguous description of the composition and structure of a chemical molecule.

The specification may contain:

• Descriptive name, number, or other specification identifier
• The time of the last revision and the mark of who performed the revision
• A logo or trademark indicating who has the right to copy, the owner and the origin of the document
• Contents of the document, if the document is long
• Responsible person or organization for specification questions, updates and deviations
• Importance, scope of the specification and its purpose
• Terms, definitions and abbreviations to clarify the specification
• Verification methods for all specified requirements and characteristics
• Material requirements: physical, mechanical, electrical, chemical and others. Target and valid
• Performance testing requirements. Target and valid
• Images, photographs or technical illustrations
• Mastery Requirements
• Certification Requirements
• Safety requirements
• Environmental requirements
• Quality assurance control, test sample, inspection, work acceptance criterion
• The person or organization responsible for fulfilling the specification
• Fulfillment and Delivery
• Conditions for deviations, rechecking, revision, adjustment of measurements and characteristics
• References and citations in the body of the specification that may be needed to establish clarity of the document
• Signatures and permissions, if required
• Change control (using special computer programs) for sequential development, verification and execution if the document is intended for internal use
• Attachments that provide details, add clarity, or clarify payment information

see also

Links

Notes

Wikimedia Foundation. 2010.

Synonyms:

• Petrovskoye (Yaroslavl region)
• Manuel II Palaiologos

See what “Specification” is in other dictionaries:

SPECIFICATION- a document made in the form of a table that defines the composition of a product. Contains the designation of components, their name and quantity (the main document used for completing products). Dictionary of financial terms... ... Financial Dictionary

SPECIFICATION- 1) a philosophical term meaning self-distinction. 2) recycling raw material or old things into the new kind or new forms that give them the appearance of new things. 3) personal or exact painting; recounting the parts that make up the whole; registry... ... Dictionary of foreign words of the Russian language

specification- and, f. specification, German Spezifikation. lat. species species, variety + facio do. 1. special Definition and list of specific features of something; classification. BAS 1. On the ramparts here there are cannons, mortars with all... ... Historical Dictionary of Gallicisms of the Russian Language

specification- enumeration, stocknote, definition, classification, document, clarification Dictionary of Russian synonyms. specification noun, number of synonyms: 6 document (82) ... Synonym dictionary

Specification- (form No. TORG 10) is used in the case when an invoiced batch of goods is packed in boxes, barrels, etc. The specification is written out in two copies by the financially responsible person of the warehouse (storeroom); one copy is attached to... ... Encyclopedic dictionary-reference book for enterprise managers

SPECIFICATION- (lat. specificatio) 1) in civil law the same as processing as a way of the emergence of property rights; 2) a list of goods offered or supplied indicating the quantity for each grade, brand, article and, if necessary... ... Legal Dictionary

Specification- a list of products produced or offered for sale, which indicates their quantity, grade, brand, quality characteristics, prices. Dictionary of business terms. Akademik.ru. 2001... Dictionary of business terms

SPECIFICATION- 1) a listing of details that need to be paid special attention to. 2) One of the main documents of technical design documentation (for a product, products, etc.), usually performed in the form of a table indicating the name ... Big Encyclopedic Dictionary

SPECIFICATION- a list of goods offered for sale or delivery, which indicates their quantity, grade, brand, quality characteristics, and, if necessary, prices. Raizberg B.A., Lozovsky L.Sh., Starodubtseva E.B.. Modern economic dictionary.… … Economic dictionary

SPECIFICATION- SPECIFICATION, specifications, women. 1. units only Action under Ch. specify; development, listing of details, details (book). 2. A document describing the manufactured item (mechanism, machine, etc.), by which it is determined... ... Dictionary Ushakova

Books

• , Sheng Liang. This book describes the JNI interface. The book will be useful to those who are interested in the following issues: - integration of code written in programming languages ​​such as C and C++ into... Buy for 1009 RUR
• JNI interface. Programming Manual and Specification, Sheng Liang. The book describes the Java Native Interface (JNI) - the interoperability interface Java language with native code written in other languages. It will be useful to Java programmers,…