metanorma-iso 1.10.0 → 1.10.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (28) hide show
  1. checksums.yaml +4 -4
  2. data/.github/workflows/ubuntu.yml +41 -0
  3. data/Gemfile +3 -4
  4. data/Makefile +44 -0
  5. data/Rakefile +1 -1
  6. data/bin/rspec +1 -2
  7. data/lib/asciidoctor/iso/basicdoc.rng +11 -1
  8. data/lib/asciidoctor/iso/biblio.rng +2 -0
  9. data/lib/asciidoctor/iso/cleanup.rb +7 -6
  10. data/lib/asciidoctor/iso/isodoc.rng +13 -1
  11. data/lib/asciidoctor/iso/isostandard-amd.rng +1 -1
  12. data/lib/asciidoctor/iso/isostandard.rng +3 -1
  13. data/lib/asciidoctor/iso/reqt.rng +1 -1
  14. data/lib/isodoc/iso/i18n.rb +10 -9
  15. data/lib/isodoc/iso/iso.amendment.xsl +27 -9
  16. data/lib/isodoc/iso/iso.international-standard.xsl +27 -9
  17. data/lib/isodoc/iso/sections.rb +2 -0
  18. data/lib/isodoc/iso/word_cleanup.rb +94 -0
  19. data/lib/isodoc/iso/word_convert.rb +12 -89
  20. data/lib/metanorma/iso/version.rb +1 -1
  21. data/spec/asciidoctor/base_spec.rb +543 -209
  22. data/spec/asciidoctor/blocks_spec.rb +0 -39
  23. data/spec/asciidoctor/refs_spec.rb +87 -4
  24. data/spec/isodoc/i18n_spec.rb +25 -11
  25. data/spec/isodoc/table_spec.rb +6 -8
  26. data/spec/vcr_cassettes/docrels.yml +783 -0
  27. data/spec/vcr_cassettes/sortrefs.yml +599 -0
  28. metadata +6 -2
data/spec/vcr_cassettes/sortrefs.yml ADDED
@@ -0,0 +1,599 @@
1
+ ---
2
+ http_interactions:
3
+ - request:
4
+ method: post
5
+ uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
6
+ body:
7
+ encoding: UTF-8
8
+ string: '{"query":"ISO 8000-110","hitsPerPage":100,"filters":"category:standard"}'
9
+ headers:
10
+ User-Agent:
11
+ - Algolia for Ruby (2.1.1), Ruby (3.0.2)
12
+ X-Algolia-Api-Key:
13
+ - dd1b9e1ab383f4d4817d29cd5e96d3f0
14
+ X-Algolia-Application-Id:
15
+ - JCL49WV5AR
16
+ Content-Type:
17
+ - application/json; charset=utf-8
18
+ Accept-Encoding:
19
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
20
+ Accept:
21
+ - "*/*"
22
+ Connection:
23
+ - keep-alive
24
+ Keep-Alive:
25
+ - '30'
26
+ response:
27
+ status:
28
+ code: 200
29
+ message: OK
30
+ headers:
31
+ Server:
32
+ - nginx
33
+ Date:
34
+ - Tue, 26 Oct 2021 13:00:59 GMT
35
+ Content-Type:
36
+ - application/json; charset=UTF-8
37
+ Transfer-Encoding:
38
+ - chunked
39
+ Connection:
40
+ - keep-alive
41
+ X-Alg-Pt:
42
+ - '1'
43
+ Accept-Encoding:
44
+ - deflate, gzip
45
+ Cache-Control:
46
+ - no-store
47
+ Access-Control-Allow-Origin:
48
+ - "*"
49
+ Timing-Allow-Origin:
50
+ - "*"
51
+ X-Content-Type-Options:
52
+ - nosniff
53
+ Strict-Transport-Security:
54
+ - max-age=31536000; includeSubDomains; preload
55
+ Content-Disposition:
56
+ - inline; filename=a.txt
57
+ body:
58
+ encoding: ASCII-8BIT
59
+ string: !binary |-
60
+ {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/16/51653","uuid":"fb607729-239e-4354-8ff7-9e5fdc7a110d","title":"ISO 8000-110:2009 Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification","status":"Published","year":2019,"order":11,"text":"ISO 8000-110:2009 specifies requirements that can be checked\nby computer for the exchange, between organizations and systems, of\nmaster data that consists of characteristic data. The focus of\nISO 8000-110:2009 is on requirements that can be checked by\ncomputer. ","objectID":"51653_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>8000-110</em>:2009 Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","110"]},"text":{"value":"<em>ISO</em> <em>8000-110</em>:2009 specifies requirements that can be checked\nby computer for the exchange, between organizations and systems, of\nmaster data that consists of characteristic data. The focus of\n<em>ISO</em> <em>8000-110</em>:2009 is on requirements that can be checked by\ncomputer. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","110"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/85/78501","uuid":"51a327c5-4364-41f4-8483-f73a2452ecab","title":"ISO 8000-110 Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification","status":"Under development","year":2021,"order":12,"objectID":"78501_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>8000-110</em> Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","110"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/00/70095","uuid":"17c414a1-4a3e-4164-a5a9-844a80ad89b3","title":"ISO 8000-115:2018 Data quality — Part 115: Master data: Exchange of quality identifiers: Syntactic, semantic and resolution requirements","status":"Published","year":2018,"order":11,"text":"ISO 8000-115:2018 specifies the requirements for the quality identifiers that form part of an exchange of master data. These requirements supplement those of ISO 8000‑110. The following are within the scope of ISO 8000-115:2018: ·                     the syntax and semantics of quality identifiers to allow the unambiguous identification of the owner of the identifier and any restrictions on the use of the identifier; ·                     the principles of resolving quality identifiers to the data set they represent; ·                     the characteristics that define quality identifiers. The following are outside the scope of ISO 8000-115:2018: ·                     the methods used for the creation of identifiers; ·                     the syntax of the query and of the response used in the resolution of identifiers; ·                     the methods used for the resolution of identifiers. ","objectID":"70095_0","_highlightResult":{"title":{"value":"<em>ISO</em> 8000-115:2018 Data quality — Part 115: Master data: Exchange of quality identifiers: Syntactic, semantic and resolution requirements","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 8000-115:2018 specifies the requirements for the quality identifiers that form part of an exchange of master data. These requirements supplement those of <em>ISO</em> <em>8000‑110</em>. The following are within the scope of <em>ISO</em> 8000-115:2018: ·                     the syntax and semantics of quality identifiers to allow the unambiguous identification of the owner of the identifier and any restrictions on the use of the identifier; ·                     the principles of resolving quality identifiers to the data set they represent; ·                     the characteristics that define quality identifiers. The following are outside the scope of <em>ISO</em> 8000-115:2018: ·                     the methods used for the creation of identifiers; ·                     the syntax of the query and of the response used in the resolution of identifiers; ·                     the methods used for the resolution of identifiers. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","110"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/23/62393","uuid":"cff29a80-c5c9-4428-87bd-b7ceb1691a02","title":"ISO 8000-120:2016 Data quality — Part 120: Master data: Exchange of characteristic data: Provenance","status":"Published","year":2021,"order":11,"text":"ISO 8000-120:2016 specifies requirements for the representation and exchange of information about the provenance of master data that consists of characteristic data, and supplements the requirements of ISO 8000‑110. ISO 8000-120:2016 does not specify a complete model for characteristic data, nor does it specify an exchange format for characteristic data with provenance information. The following are within the scope of ISO 8000-120:2016: ·         scenarios for data provenance; ·         requirements for capture and exchange of data provenance information; ·         data model for data provenance information. The following are outside the scope of ISO 8000-120:2016: ·         exchange format for data provenance information; ·         scheme for registering and resolving organization identifiers and person identifiers; ·         provenance of data that are not characteristic data represented as property values; ·         configuration management; ·         change control; ·         syntax of identifiers; ·         resolution of identifiers. Some of the requirements in ISO 8000-120:2016 can apply to exchange of data that is not master data which consists of characteristic data represented as property values. ","objectID":"62393_0","_highlightResult":{"title":{"value":"<em>ISO</em> 8000-120:2016 Data quality — Part 120: Master data: Exchange of characteristic data: Provenance","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 8000-120:2016 specifies requirements for the representation and exchange of information about the provenance of master data that consists of characteristic data, and supplements the requirements of <em>ISO</em> <em>8000‑110</em>. <em>ISO</em> 8000-120:2016 does not specify a complete model for characteristic data, nor does it specify an exchange format for characteristic data with provenance information. The following are within the scope of <em>ISO</em> 8000-120:2016: ·         scenarios for data provenance; ·         requirements for capture and exchange of data provenance information; ·         data model for data provenance information. The following are outside the scope of <em>ISO</em> 8000-120:2016: ·         exchange format for data provenance information; ·         scheme for registering and resolving organization identifiers and person identifiers; ·         provenance of data that are not characteristic data represented as property values; ·         configuration management; ·         change control; ·         syntax of identifiers; ·         resolution of identifiers. Some of the requirements in <em>ISO</em> 8000-120:2016 can apply to exchange of data that is not master data which consists of characteristic data represented as property values. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","110"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/08/50801","uuid":"629e8c8a-9269-4446-ae87-22204e1cf528","title":"ISO/TS 8000-120:2009 Data quality — Part 120: Master data: Exchange of characteristic data: Provenance","status":"Withdrawn","year":2016,"order":100,"text":"ISO/TS 8000-120:2009 specifies requirements for the\nrepresentation and exchange of information about the provenance of\nmaster data that consists of characteristic data, and supplements\nthe requirements of ISO 8000-110. Provenance is the history or\npedigree of a property value. Any claim of conformance to ISO/TS\n8000-120:2009 implies a claim of conformance to ISO 8000-110.\nISO/TS 8000-120:2009 includes a Unified Modeling Language (UML)\nconceptual model for provenance data. Just as provenance is a key\nelement of the value of a work of art, it is also a key element of\nthe value of data. It allows the recipient of a master data message\nto trace master data that has been exchanged back to its source,\nand helps the recipient to assess the trustworthiness of the data,\nand make a choice when values for the same property are received\nfrom different sources. ","objectID":"50801_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 8000-120:2009 Data quality — Part 120: Master data: Exchange of characteristic data: Provenance","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em>/TS 8000-120:2009 specifies requirements for the\nrepresentation and exchange of information about the provenance of\nmaster data that consists of characteristic data, and supplements\nthe requirements of <em>ISO</em> <em>8000-110</em>. Provenance is the history or\npedigree of a property value. Any claim of conformance to <em>ISO</em>/TS\n8000-120:2009 implies a claim of conformance to <em>ISO</em> <em>8000-110</em>.\n<em>ISO</em>/TS 8000-120:2009 includes a Unified Modeling Language (UML)\nconceptual model for provenance data. Just as provenance is a key\nelement of the value of a work of art, it is also a key element of\nthe value of data. It allows the recipient of a master data message\nto trace master data that has been exchanged back to its source,\nand helps the recipient to assess the trustworthiness of the data,\nand make a choice when values for the same property are received\nfrom different sources. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","110"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/23/62395","uuid":"1c10b7f7-b958-4275-b768-b4ac06ed1107","title":"ISO 8000-140:2016 Data quality — Part 140: Master data: Exchange of characteristic data: Completeness","status":"Published","year":2021,"order":11,"text":"ISO 8000-140:2016 is an optional addition to ISO 8000‑120 and specifies requirements for representation and exchange of information about completeness of master data that consists of characteristic data. NOTE 1       ISO 8000‑110 specifies that such data be represented as property values. ISO 8000‑120 provides additional requirements for property values when data provenance information needs to be captured. ISO 8000-140:2016 does not specify a complete model for characteristic data, nor does it specify an exchange format for characteristic data with data completeness information. NOTE 2       This is done in other standards that reference this part of ISO 8000, e.g. ISO/TS 22745‑40. The following are within the scope of this part of ISO 8000: -      requirements for capture and exchange of data completeness information in the form of statements and assertions of data completeness; -      conceptual data model for data completeness information in the form of statements and assertions of data completeness. The following are outside the scope of this part of ISO 8000: -      requirements for data completeness; NOTE 3       The requirements for data completeness depend on many factors, e.g. the kind of data, how the data are being used, industry, and needs of the partners exchanging the data. It is not possible to state general requirements for data completeness. -      exchange format for data completeness information; -      scheme for registering and resolving organization identifiers and person identifiers; -      completeness of data that are not characteristic data represented as property values; -      syntax of identifiers; -      resolution of identifiers. Some of the requirements in ISO 8000-140:2016 can apply to exchange of data that is not master data which consists of characteristic data represented as property values. ","objectID":"62395_0","_highlightResult":{"title":{"value":"<em>ISO</em> 8000-140:2016 Data quality — Part 140: Master data: Exchange of characteristic data: Completeness","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em> 8000-140:2016 is an optional addition to <em>ISO</em> 8000‑120 and specifies requirements for representation and exchange of information about completeness of master data that consists of characteristic data. NOTE 1       <em>ISO</em> <em>8000‑110</em> specifies that such data be represented as property values. <em>ISO</em> 8000‑120 provides additional requirements for property values when data provenance information needs to be captured. <em>ISO</em> 8000-140:2016 does not specify a complete model for characteristic data, nor does it specify an exchange format for characteristic data with data completeness information. NOTE 2       This is done in other standards that reference this part of <em>ISO</em> 8000, e.g. <em>ISO</em>/TS 22745‑40. The following are within the scope of this part of <em>ISO</em> 8000: -      requirements for capture and exchange of data completeness information in the form of statements and assertions of data completeness; -      conceptual data model for data completeness information in the form of statements and assertions of data completeness. The following are outside the scope of this part of <em>ISO</em> 8000: -      requirements for data completeness; NOTE 3       The requirements for data completeness depend on many factors, e.g. the kind of data, how the data are being used, industry, and needs of the partners exchanging the data. It is not possible to state general requirements for data completeness. -      exchange format for data completeness information; -      scheme for registering and resolving organization identifiers and person identifiers; -      completeness of data that are not characteristic data represented as property values; -      syntax of identifiers; -      resolution of identifiers. Some of the requirements in <em>ISO</em> 8000-140:2016 can apply to exchange of data that is not master data which consists of characteristic data represented as property values. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","110"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/08/50800","uuid":"cce58750-3584-479d-acee-7c6566762f4e","title":"ISO/TS 8000-110:2008 Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification","status":"Withdrawn","year":2009,"order":100,"text":"ISO/TS 8000-110:2008 specifies general, syntax, semantic encoding and data specification requirements for master data messages\n         between organizations and systems. The focus of ISO/TS 8000-110:2008 is on requirements that can be checked by computer. ","objectID":"50800_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS <em>8000-110</em>:2008 Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","110"]},"text":{"value":"<em>ISO</em>/TS <em>8000-110</em>:2008 specifies general, syntax, semantic encoding and data specification requirements for master data messages\n         between organizations and systems. The focus of <em>ISO</em>/TS <em>8000-110</em>:2008 is on requirements that can be checked by computer. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","110"]}}}],"nbHits":7,"page":0,"nbPages":1,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 8000-110","params":"query=ISO+8000-110&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":1}
61
+ http_version:
62
+ recorded_at: Tue, 26 Oct 2021 13:00:59 GMT
63
+ - request:
64
+ method: get
65
+ uri: https://www.iso.org/contents/data/standard/05/16/51653.html
66
+ body:
67
+ encoding: US-ASCII
68
+ string: ''
69
+ headers:
70
+ Accept-Encoding:
71
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
72
+ Accept:
73
+ - "*/*"
74
+ User-Agent:
75
+ - Ruby
76
+ Host:
77
+ - www.iso.org
78
+ response:
79
+ status:
80
+ code: 301
81
+ message: ''
82
+ headers:
83
+ Expires:
84
+ - Wed, 09 May 1979 05:30:00 GMT
85
+ Cache-Control:
86
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
87
+ Pragma:
88
+ - no-cache
89
+ Set-Cookie:
90
+ - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
91
+ Secure
92
+ - JSESSIONID=8DEAE6338137FEAAEFD361944DFA2E32; Path=/; Secure; HttpOnly
93
+ Location:
94
+ - "/standard/51653.html"
95
+ Content-Length:
96
+ - '0'
97
+ Date:
98
+ - Tue, 26 Oct 2021 13:01:01 GMT
99
+ Strict-Transport-Security:
100
+ - max-age=31536000; includeSubDomains
101
+ body:
102
+ encoding: UTF-8
103
+ string: ''
104
+ http_version:
105
+ recorded_at: Tue, 26 Oct 2021 13:01:01 GMT
106
+ - request:
107
+ method: get
108
+ uri: https://www.iso.org/standard/51653.html
109
+ body:
110
+ encoding: US-ASCII
111
+ string: ''
112
+ headers:
113
+ Accept-Encoding:
114
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
115
+ Accept:
116
+ - "*/*"
117
+ User-Agent:
118
+ - Ruby
119
+ Host:
120
+ - www.iso.org
121
+ response:
122
+ status:
123
+ code: 200
124
+ message: ''
125
+ headers:
126
+ Expires:
127
+ - Wed, 09 May 1979 05:30:00 GMT
128
+ Cache-Control:
129
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
130
+ Pragma:
131
+ - no-cache
132
+ Set-Cookie:
133
+ - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
134
+ Secure
135
+ - JSESSIONID=026A896AA59F50563C3999268AAABEDC; Path=/; Secure; HttpOnly
136
+ Vary:
137
+ - accept-encoding
138
+ Content-Type:
139
+ - text/html;charset=UTF-8
140
+ Transfer-Encoding:
141
+ - chunked
142
+ Date:
143
+ - Tue, 26 Oct 2021 08:01:02 CDT
144
+ Strict-Transport-Security:
145
+ - max-age=31536000; includeSubDomains
146
+ body:
147
+ encoding: ASCII-8BIT
148
+ string: !binary |-
149
+ <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 8000-110:2009 - Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/51653.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1627457321310" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1627457321310"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1630493922153"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20190516" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/05/16/51653.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 8000-110:2009" />
    <meta property="og:title" content="ISO 8000-110:2009" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification" />
    <meta property="og:description" content="Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification" />
    <meta name="description" content="Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/home/about-us/strategy-2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/51653.html">français</a></li><li><a href="/ru/standard/51653.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="51653 - ISO 8000-110:2009 - Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification"></span>

  <span class="hidden" id="itemReference">ISO 8000-110:2009</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">51653</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/25.html">25</a> >&nbsp;<a href="/en/ics/25.040.html">25.040</a> >&nbsp;<a href="/en/ics/25.040.40.html">25.040.40</a></div>
  

  <h1>ISO 8000-110:2009</h1>
  <h2 class="no-uppercase">Data quality — Part 110: Master data: Exchange of characteristic data: Syntax, semantic encoding, and conformance to data specification</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:51653:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>ISO 8000-110:2009 specifies requirements that can be checked
by computer for the exchange, between organizations and systems, of
master data that consists of characteristic data. The focus of
ISO 8000-110:2009 is on requirements that can be checked by
computer.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/05/16/51653.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2009-11</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 1
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 1
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/54158.html">ISO/TC 184/SC 4</a>
        </div>
        <div class="entry-title">Industrial data</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/25.040.40.html">
                25.040.40
            </a>
          </div>
          <div class="entry-title">Industrial process measurement and control</div>
        </dd>
      
    </dl>
  </li>
</ul>

      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">38</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                HTML
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub000000289pIAAQ~a05b0000005WV1uAAG~a0fb0000000ePZ4AAM~a0cb0000001QRB8AAO" lang="en" selected>
                      English
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">38</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                HTML on CD
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub000000289pIAAQ~a05b0000005WV21AAG~a0fb0000000ePa1AAE~a0cb0000001QR8cAAG" lang="en" selected>
                      English
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">38</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Previously</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Withdrawn</div>
                    <h5><a href="/standard/50800.html">ISO/TS 8000-110:2008</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                <div class="step step-success active">
                  <div class="section-head">Published</div>
                  
              <h5>ISO 8000-110:2009</h5>
                  <br/>A standard is reviewed every 5 years<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>90.92</strong> (To be revised)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2008-09-16</span>
                              <div class="stage-title">
                                New project approved
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2008-09-25</span>
                              <div class="stage-title">
                                CD approved for registration as DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2008-09-25</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2008-10-06</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2009-03-08</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2009-08-12</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2009-09-07</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2009-09-30</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2009-10-27</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2009-10-27</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2009-11-05</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2014-10-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2015-03-18</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/stage-codes.html#90_92">
                              <span class="stage-code">90.92</span>
                              <span class="stage-date">2019-05-16</span>
                              <div class="stage-title">
                                International Standard to be revised
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                      </a>

                      
                    </li>
                  
              </ul>

                  
            </li>
            
              <li class="time-step">

              
                  <h4 class="text-help">Revised by</h4>
                  <div class="step step-success">
                
                  <div class="step-item">
                    <div class="section-head">Under development</div>
                    <h5><a href="/standard/78501.html">ISO 8000-110</a></h5>
                  </div>
                </div>
              </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/25.html">25</a></li>
    
      <li><a href="/en/ics/25.040.html">25.040</a></li>
    
      <li><a href="/en/ics/25.040.40.html">25.040.40</a></li>
    <li>ISO 8000-110:2009</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
150
+ http_version:
151
+ recorded_at: Tue, 26 Oct 2021 13:01:03 GMT
152
+ - request:
153
+ method: post
154
+ uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
155
+ body:
156
+ encoding: UTF-8
157
+ string: '{"query":"ISO 8000-61","hitsPerPage":100,"filters":"category:standard"}'
158
+ headers:
159
+ User-Agent:
160
+ - Algolia for Ruby (2.1.1), Ruby (3.0.2)
161
+ X-Algolia-Api-Key:
162
+ - dd1b9e1ab383f4d4817d29cd5e96d3f0
163
+ X-Algolia-Application-Id:
164
+ - JCL49WV5AR
165
+ Content-Type:
166
+ - application/json; charset=utf-8
167
+ Accept-Encoding:
168
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
169
+ Accept:
170
+ - "*/*"
171
+ Connection:
172
+ - keep-alive
173
+ Keep-Alive:
174
+ - '30'
175
+ response:
176
+ status:
177
+ code: 200
178
+ message: OK
179
+ headers:
180
+ Server:
181
+ - nginx
182
+ Date:
183
+ - Tue, 26 Oct 2021 13:01:04 GMT
184
+ Content-Type:
185
+ - application/json; charset=UTF-8
186
+ Transfer-Encoding:
187
+ - chunked
188
+ Connection:
189
+ - keep-alive
190
+ X-Alg-Pt:
191
+ - '1'
192
+ Accept-Encoding:
193
+ - deflate, gzip
194
+ Cache-Control:
195
+ - no-store
196
+ Access-Control-Allow-Origin:
197
+ - "*"
198
+ Timing-Allow-Origin:
199
+ - "*"
200
+ X-Content-Type-Options:
201
+ - nosniff
202
+ Strict-Transport-Security:
203
+ - max-age=31536000; includeSubDomains; preload
204
+ Content-Disposition:
205
+ - inline; filename=a.txt
206
+ body:
207
+ encoding: ASCII-8BIT
208
+ string: !binary |-
209
+ {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/30/63086","uuid":"99009042-44eb-43ce-8966-685b00d05fd7","title":"ISO 8000-61:2016 Data quality — Part 61: Data quality management: Process reference model","status":"Published","year":2021,"order":11,"text":"ISO 8000-61:2016 specifies the processes required for data quality management. The processes are used as a reference to enhance data quality and assess process capability or organizational maturity for data quality management. ","objectID":"63086_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>8000-61</em>:2016 Data quality — Part 61: Data quality management: Process reference model","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","61"]},"text":{"value":"<em>ISO</em> <em>8000-61</em>:2016 specifies the processes required for data quality management. The processes are used as a reference to enhance data quality and assess process capability or organizational maturity for data quality management. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","61"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/38/73835","uuid":"e73de8de-bdc7-40ad-ae25-4b56bdfb872d","title":"ISO/TS 8000-65:2020 Data quality — Part 65: Data quality management: Process measurement questionnaire","status":"Published","year":2020,"order":11,"text":"This document specifies a questionnaire to audit the performance of the processes specified by the process reference model in ISO 8000‑61. NOTE 1  This questionnaire is applicable to all types of business process, technology, information system, data and data processing. This questionnaire can be used as part of a continuous improvement process. The following are within the scope of this document: —     guiding principles for generating questions from the process outcomes specified by ISO 8000‑61; —     one or more questions for each outcome of every process in ISO 8000‑61; —     a measurement method based on a simple indicator and measurement scale for each question; —     guidance on how to present the results generated by the questionnaire. NOTE 2  The questions and corresponding indicators in this document conform to the requirements of ISO 8000‑63. The following is outside the scope of this document: —     defining how the questions relate to models of organizational process maturity. NOTE 3  Such models define an overall scale by which to understand the degree to which an organization is performing effectively and efficiently. EXAMPLE    ISO 8000‑62 and ISO 8000‑64 [1]specify how to use maturity models with ISO 8000‑61. [1] Under preparation. ","objectID":"73835_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 8000-65:2020 Data quality — Part 65: Data quality management: Process measurement questionnaire","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies a questionnaire to audit the performance of the processes specified by the process reference model in <em>ISO</em> <em>8000‑61</em>. NOTE 1  This questionnaire is applicable to all types of business process, technology, information system, data and data processing. This questionnaire can be used as part of a continuous improvement process. The following are within the scope of this document: —     guiding principles for generating questions from the process outcomes specified by <em>ISO</em> <em>8000‑61</em>; —     one or more questions for each outcome of every process in <em>ISO</em> <em>8000‑61</em>; —     a measurement method based on a simple indicator and measurement scale for each question; —     guidance on how to present the results generated by the questionnaire. NOTE 2  The questions and corresponding indicators in this document conform to the requirements of <em>ISO</em> 8000‑63. The following is outside the scope of this document: —     defining how the questions relate to models of organizational process maturity. NOTE 3  Such models define an overall scale by which to understand the degree to which an organization is performing effectively and efficiently. EXAMPLE    <em>ISO</em> 8000‑62 and <em>ISO</em> 8000‑64 [1]specify how to use maturity models with <em>ISO</em> <em>8000‑61</em>. [1] Under preparation. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","61"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/53/65340","uuid":"cb2a6ce8-fd07-4fb1-914f-35155f7b9133","title":"ISO 8000-62:2018 Data quality — Part 62: Data quality management: Organizational process maturity assessment: Application of standards relating to process assessment","status":"Published","year":2018,"order":11,"text":"This document specifies particular elements of a maturity model. These elements conform to ISO/IEC 33004. Organizations can use these elements in combination with their own assessment indicators to determine the maturity level of processes for data quality management as specified by ISO 8000‑61. The following are within the scope of this document: -      some of the elements of a model for assessing organizational process maturity; -      identifying those elements that exist in other standards (process capability levels, process attributes, ordinal scale for measuring process attributes and the scheme for derivation of process capability levels from process attribute rating); -      specifying six maturity levels and process profiles to indicate when organizations have achieved each of the maturity levels; -      providing guidance on how to assess the maturity level of an organization. Methods or procedures to improve organizational maturity are outside the scope of this document. This document can be used by the organization itself or by another party (including certification bodies) to perform assessment of the maturity. This document can be used in conjunction with, or independently of, quality management systems standards. ","objectID":"65340_0","_highlightResult":{"title":{"value":"<em>ISO</em> 8000-62:2018 Data quality — Part 62: Data quality management: Organizational process maturity assessment: Application of standards relating to process assessment","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies particular elements of a maturity model. These elements conform to <em>ISO</em>/IEC 33004. Organizations can use these elements in combination with their own assessment indicators to determine the maturity level of processes for data quality management as specified by <em>ISO</em> <em>8000‑61</em>. The following are within the scope of this document: -      some of the elements of a model for assessing organizational process maturity; -      identifying those elements that exist in other standards (process capability levels, process attributes, ordinal scale for measuring process attributes and the scheme for derivation of process capability levels from process attribute rating); -      specifying six maturity levels and process profiles to indicate when organizations have achieved each of the maturity levels; -      providing guidance on how to assess the maturity level of an organization. Methods or procedures to improve organizational maturity are outside the scope of this document. This document can be used by the organization itself or by another party (including certification bodies) to perform assessment of the maturity. This document can be used in conjunction with, or independently of, quality management systems standards. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","61"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/63/76390","uuid":"6fc20c40-16fa-43bc-96ba-96097243956e","title":"ISO 8000-66:2021 Data quality — Part 66: Data quality management: Assessment indicators for data processing in manufacturing operations","status":"Published","year":2021,"order":11,"text":"This document specifies assessment indicators to support the assessment of organizational process maturity for data quality management in the context of manufacturing operations management as specified by IEC 62264‑1. The following are within scope of this document: —    assessment indicators that are work products generated by data processing (as specified by ISO 8000‑61) and, thus, enable rating of process performance, a process attribute specified by ISO/IEC 33020; —    the role played by each work product in the processes of manufacturing operations management; —    the connection of each work product to the outcomes of the processes of manufacturing operations management. The following are outside the scope of this document: —    assessment indicators for any of the other process attributes specified by ISO/IEC 33020; —    methods or procedures to measure process capability. ","objectID":"76390_0","_highlightResult":{"title":{"value":"<em>ISO</em> 8000-66:2021 Data quality — Part 66: Data quality management: Assessment indicators for data processing in manufacturing operations","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies assessment indicators to support the assessment of organizational process maturity for data quality management in the context of manufacturing operations management as specified by IEC 62264‑1. The following are within scope of this document: —    assessment indicators that are work products generated by data processing (as specified by <em>ISO</em> <em>8000‑61</em>) and, thus, enable rating of process performance, a process attribute specified by <em>ISO</em>/IEC 33020; —    the role played by each work product in the processes of manufacturing operations management; —    the connection of each work product to the outcomes of the processes of manufacturing operations management. The following are outside the scope of this document: —    assessment indicators for any of the other process attributes specified by <em>ISO</em>/IEC 33020; —    methods or procedures to measure process capability. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","61"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/62/66234","uuid":"913400d1-7621-4a58-9201-9c68678ce7b1","title":"ISO/TS 8000-60:2017 Data quality — Part 60: Data quality management: Overview","status":"Published","year":2021,"order":11,"text":"ISO/TS 8000‑60:2017 introduces the concepts within the parts of ISO 8000 related to implementing, assessing and improving data quality management. The following are within the scope of ISO/TS 8000‑60:2017: ·         a statement of the overall scope of those parts of ISO 8000 related to data quality management; ·         an overview of ISO 8000‑61, which specifies a process reference model for data quality management; ·         an overview of ISO 8000‑62, which specifies a model that conforms to some of the requirements of ISO/IEC 33004 and that establishes a basis on which to determine the maturity of an organization with respect to data quality management; ·         an overview of ISO 8000-63, which specifies the measurement procedure and measurement stack by which to measure the characteristics of processes for data quality management; ·         an overview of ISO 8000‑64, which specifies a model that applies the Test Process Improvement method as a basis on which to determine the maturity of an organization with respect to data quality management. The details for implementing the parts of ISO 8000 related to data quality management are outside the scope of ISO/TS 8000‑60:2017. ","objectID":"66234_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS 8000-60:2017 Data quality — Part 60: Data quality management: Overview","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"<em>ISO</em>/TS 8000‑60:2017 introduces the concepts within the parts of <em>ISO</em> 8000 related to implementing, assessing and improving data quality management. The following are within the scope of <em>ISO</em>/TS 8000‑60:2017: ·         a statement of the overall scope of those parts of <em>ISO</em> 8000 related to data quality management; ·         an overview of <em>ISO</em> <em>8000‑61</em>, which specifies a process reference model for data quality management; ·         an overview of <em>ISO</em> 8000‑62, which specifies a model that conforms to some of the requirements of <em>ISO</em>/IEC 33004 and that establishes a basis on which to determine the maturity of an organization with respect to data quality management; ·         an overview of <em>ISO</em> 8000-63, which specifies the measurement procedure and measurement stack by which to measure the characteristics of processes for data quality management; ·         an overview of <em>ISO</em> 8000‑64, which specifies a model that applies the Test Process Improvement method as a basis on which to determine the maturity of an organization with respect to data quality management. The details for implementing the parts of <em>ISO</em> 8000 related to data quality management are outside the scope of <em>ISO</em>/TS 8000‑60:2017. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","61"]}}}],"nbHits":5,"page":0,"nbPages":1,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 8000-61","params":"query=ISO+8000-61&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":1}
210
+ http_version:
211
+ recorded_at: Tue, 26 Oct 2021 13:01:04 GMT
212
+ - request:
213
+ method: get
214
+ uri: https://www.iso.org/contents/data/standard/06/30/63086.html
215
+ body:
216
+ encoding: US-ASCII
217
+ string: ''
218
+ headers:
219
+ Accept-Encoding:
220
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
221
+ Accept:
222
+ - "*/*"
223
+ User-Agent:
224
+ - Ruby
225
+ Host:
226
+ - www.iso.org
227
+ response:
228
+ status:
229
+ code: 301
230
+ message: ''
231
+ headers:
232
+ Expires:
233
+ - Wed, 09 May 1979 05:30:00 GMT
234
+ Cache-Control:
235
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
236
+ Pragma:
237
+ - no-cache
238
+ Set-Cookie:
239
+ - BIGipServerpool_prod_iso_www-jahia=713576842.36895.0000; path=/; Httponly;
240
+ Secure
241
+ - JSESSIONID=B2A66149C890D3332B78ED84B613E3CE; Path=/; Secure; HttpOnly
242
+ Location:
243
+ - "/standard/63086.html"
244
+ Content-Length:
245
+ - '0'
246
+ Date:
247
+ - Tue, 26 Oct 2021 13:01:05 GMT
248
+ Strict-Transport-Security:
249
+ - max-age=31536000; includeSubDomains
250
+ body:
251
+ encoding: UTF-8
252
+ string: ''
253
+ http_version:
254
+ recorded_at: Tue, 26 Oct 2021 13:01:05 GMT
255
+ - request:
256
+ method: get
257
+ uri: https://www.iso.org/standard/63086.html
258
+ body:
259
+ encoding: US-ASCII
260
+ string: ''
261
+ headers:
262
+ Accept-Encoding:
263
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
264
+ Accept:
265
+ - "*/*"
266
+ User-Agent:
267
+ - Ruby
268
+ Host:
269
+ - www.iso.org
270
+ response:
271
+ status:
272
+ code: 200
273
+ message: ''
274
+ headers:
275
+ Expires:
276
+ - Wed, 09 May 1979 05:30:00 GMT
277
+ Cache-Control:
278
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
279
+ Pragma:
280
+ - no-cache
281
+ Set-Cookie:
282
+ - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
283
+ Secure
284
+ - JSESSIONID=E0BC9A5D55B049D106361856EDBE0B86; Path=/; Secure; HttpOnly
285
+ Vary:
286
+ - accept-encoding
287
+ Content-Type:
288
+ - text/html;charset=UTF-8
289
+ Transfer-Encoding:
290
+ - chunked
291
+ Date:
292
+ - Tue, 26 Oct 2021 13:01:07 GMT
293
+ Strict-Transport-Security:
294
+ - max-age=31536000; includeSubDomains
295
+ body:
296
+ encoding: ASCII-8BIT
297
+ string: !binary |-
298
+ <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 8000-61:2016 - Data quality — Part 61: Data quality management: Process reference model</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/63086.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1627457321310" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1627457321310"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1630493922153"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20211015" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/06/30/63086.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 8000-61:2016" />
    <meta property="og:title" content="ISO 8000-61:2016" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Data quality — Part 61: Data quality management: Process reference model" />
    <meta property="og:description" content="Data quality — Part 61: Data quality management: Process reference model" />
    <meta name="description" content="Data quality — Part 61: Data quality management: Process reference model" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/home/about-us/strategy-2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/63086.html">français</a></li><li><a href="/ru/standard/63086.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="63086 - ISO 8000-61:2016 - Data quality — Part 61: Data quality management: Process reference model"></span>

  <span class="hidden" id="itemReference">ISO 8000-61:2016</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">63086</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/25.html">25</a> >&nbsp;<a href="/en/ics/25.040.html">25.040</a> >&nbsp;<a href="/en/ics/25.040.40.html">25.040.40</a></div>
  

  <h1>ISO 8000-61:2016</h1>
  <h2 class="no-uppercase">Data quality — Part 61: Data quality management: Process reference model</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:63086:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>ISO 8000-61:2016 specifies the processes required for data quality management. The processes are used as a reference to enhance data quality and assess process capability or organizational maturity for data quality management. </p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/06/30/63086.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2016-11</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 1
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 21
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/54158.html">ISO/TC 184/SC 4</a>
        </div>
        <div class="entry-title">Industrial data</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/25.040.40.html">
                25.040.40
            </a>
          </div>
          <div class="entry-title">Industrial process measurement and control</div>
        </dd>
      
    </dl>
  </li>
</ul>

      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">118</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub000000xDNyeAAG~a05b0000005WV2mAAG~a0fb000000EdFs1AAF~a0cb0000008JjoFAAS" lang="en" selected>
                      English
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">118</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Paper
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub000000xDNyeAAG~a05b0000005WV2rAAG~a0fb000000EdFrIAAV~a0cb0000008JjnWAAS" lang="en" selected>
                      English
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">118</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Published</div>
                    
              <h5>ISO 8000-61:2016</h5>
                  <br/>A standard is reviewed every 5 years<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>90.20</strong> (Under review)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2012-05-02</span>
                              <div class="stage-title">
                                New project approved
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#30_00">
                              <span class="stage-code">30.00</span>
                              <span class="stage-date">2013-11-13</span>
                              <div class="stage-title">
                                Committee draft (CD) registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_20">
                              <span class="stage-code">30.20</span>
                              <span class="stage-date">2013-11-13</span>
                              <div class="stage-title">
                                CD study/ballot initiated
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_60">
                              <span class="stage-code">30.60</span>
                              <span class="stage-date">2014-01-15</span>
                              <div class="stage-title">
                                Close of voting/ comment period
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2014-01-15</span>
                              <div class="stage-title">
                                CD approved for registration as DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2015-10-27</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2016-01-04</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2016-04-06</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2016-04-15</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2016-09-13</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2016-09-13</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2016-10-12</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2016-10-12</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2016-11-17</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li class="active" class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2021-10-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                      </a>

                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/25.html">25</a></li>
    
      <li><a href="/en/ics/25.040.html">25.040</a></li>
    
      <li><a href="/en/ics/25.040.40.html">25.040.40</a></li>
    <li>ISO 8000-61:2016</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
299
+ http_version:
300
+ recorded_at: Tue, 26 Oct 2021 13:01:07 GMT
301
+ - request:
302
+ method: post
303
+ uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
304
+ body:
305
+ encoding: UTF-8
306
+ string: '{"query":"ISO 8000-8","hitsPerPage":100,"filters":"category:standard"}'
307
+ headers:
308
+ User-Agent:
309
+ - Algolia for Ruby (2.1.1), Ruby (3.0.2)
310
+ X-Algolia-Api-Key:
311
+ - dd1b9e1ab383f4d4817d29cd5e96d3f0
312
+ X-Algolia-Application-Id:
313
+ - JCL49WV5AR
314
+ Content-Type:
315
+ - application/json; charset=utf-8
316
+ Accept-Encoding:
317
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
318
+ Accept:
319
+ - "*/*"
320
+ Connection:
321
+ - keep-alive
322
+ Keep-Alive:
323
+ - '30'
324
+ response:
325
+ status:
326
+ code: 200
327
+ message: OK
328
+ headers:
329
+ Server:
330
+ - nginx
331
+ Date:
332
+ - Tue, 26 Oct 2021 13:01:09 GMT
333
+ Content-Type:
334
+ - application/json; charset=UTF-8
335
+ Transfer-Encoding:
336
+ - chunked
337
+ Connection:
338
+ - keep-alive
339
+ X-Alg-Pt:
340
+ - '1'
341
+ Accept-Encoding:
342
+ - deflate, gzip
343
+ Cache-Control:
344
+ - no-store
345
+ Access-Control-Allow-Origin:
346
+ - "*"
347
+ Timing-Allow-Origin:
348
+ - "*"
349
+ X-Content-Type-Options:
350
+ - nosniff
351
+ Strict-Transport-Security:
352
+ - max-age=31536000; includeSubDomains; preload
353
+ Content-Disposition:
354
+ - inline; filename=a.txt
355
+ body:
356
+ encoding: ASCII-8BIT
357
+ string: !binary |-
358
+ {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/08/60805","uuid":"30f260c2-3fc7-46c6-b9da-b88d595d4211","title":"ISO 8000-8:2015 Data quality — Part 8: Information and data quality: Concepts and measuring","status":"Published","year":2021,"order":11,"text":"ISO 8000-8:2015 describes fundamental concepts of information and data quality, and how these concepts apply to quality management processes and quality management systems. It also specifies prerequisites for measuring information and data quality when executed within quality management processes and quality management systems. ","objectID":"60805_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>8000-8</em>:2015 Data quality — Part 8: Information and data quality: Concepts and measuring","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","8"]},"text":{"value":"<em>ISO</em> <em>8000-8</em>:2015 describes fundamental concepts of information and data quality, and how these concepts apply to quality management processes and quality management systems. It also specifies prerequisites for measuring information and data quality when executed within quality management processes and quality management systems. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","8"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/72/77227","uuid":"13f96c86-7449-4779-8495-4ba40093e042","title":"ISO/TS 8000-81:2021 Data quality — Part 81: Data quality assessment: Profiling","status":"Published","year":2021,"order":11,"text":"This document specifies a procedure for data profiling to generate the foundation for performing data quality assessment. This profiling is applicable to data sets that are either originally in a structure of tables and columns or are the output from a transformation to create such a structure. NOTE 1    Data profiling is applicable to all types of database technology. The following are within the scope of this document: —    performing structure analysis to determine data element concepts; —    performing column analysis to identify relevant data elements, including statistics about a data set; —    performing relationship analysis to identify dependencies in a data set. The following are outside the scope of this document: —    methods for extracting and sampling data to be profiled from a data set; —    deriving data rules; —    measuring the extent of nonconformities in a data set. NOTE 2    ISO 8000‑8 specifies approaches to measuring data and information quality. This document can be used in conjunction with, or independently of, quality management systems standards. ","objectID":"77227_0","_highlightResult":{"title":{"value":"<em>ISO</em>/TS <em>8000-8</em>1:2021 Data quality — Part 81: Data quality assessment: Profiling","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","8"]},"text":{"value":"This document specifies a procedure for data profiling to generate the foundation for performing data quality assessment. This profiling is applicable to data sets that are either originally in a structure of tables and columns or are the output from a transformation to create such a structure. NOTE 1    Data profiling is applicable to all types of database technology. The following are within the scope of this document: —    performing structure analysis to determine data element concepts; —    performing column analysis to identify relevant data elements, including statistics about a data set; —    performing relationship analysis to identify dependencies in a data set. The following are outside the scope of this document: —    methods for extracting and sampling data to be profiled from a data set; —    deriving data rules; —    measuring the extent of nonconformities in a data set. NOTE 2    <em>ISO</em> <em>8000‑8</em> specifies approaches to measuring data and information quality. This document can be used in conjunction with, or independently of, quality management systems standards. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","8"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/53/65344","uuid":"2cfef028-692c-4add-8e3d-a2d922f1aaca","title":"ISO 8000-63:2019 Data quality — Part 63: Data quality management: Process measurement","status":"Published","year":2019,"order":11,"text":"This document specifies a structure for process measurement stacks that organizations can instantiate to measure the characteristics of processes for data quality management. This structure consists of goal, sub goal, question, indicator and metric. The instantiated stack consists of content that is determined by a chosen model for assessing the maturity of the processes under consideration. The following are within the scope of this document: —     the fundamentals of process measurement; —     the inspection plan and inspection order by which to perform measurement; —     the structure of the measurement stack; —     the role of the chosen maturity model in instantiating the stack. The following are outside the scope of this document: —     methods for inspecting implemented processes; —     methods for generating measured values from the inspection of processes; —     how to choose a suitable maturity model. This document can be used in conjunction with, or independently of, quality management systems standards. NOTE    ISO 8000‑8 specifies concepts and methods for measuring information and data quality. ","objectID":"65344_0","_highlightResult":{"title":{"value":"<em>ISO</em> 8000-63:2019 Data quality — Part 63: Data quality management: Process measurement","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]},"text":{"value":"This document specifies a structure for process measurement stacks that organizations can instantiate to measure the characteristics of processes for data quality management. This structure consists of goal, sub goal, question, indicator and metric. The instantiated stack consists of content that is determined by a chosen model for assessing the maturity of the processes under consideration. The following are within the scope of this document: —     the fundamentals of process measurement; —     the inspection plan and inspection order by which to perform measurement; —     the structure of the measurement stack; —     the role of the chosen maturity model in instantiating the stack. The following are outside the scope of this document: —     methods for inspecting implemented processes; —     methods for generating measured values from the inspection of processes; —     how to choose a suitable maturity model. This document can be used in conjunction with, or independently of, quality management systems standards. NOTE    <em>ISO</em> <em>8000‑8</em> specifies concepts and methods for measuring information and data quality. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","8"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/87/78707","uuid":"5af7f017-a425-4859-ade2-6133115a4ea7","title":"ISO/DTS 8000-82 Data quality — Part 82: Data quality assessment: Creating data rules","status":"Under development","year":2021,"order":12,"objectID":"78707_0","_highlightResult":{"title":{"value":"<em>ISO</em>/DTS <em>8000-8</em>2 Data quality — Part 82: Data quality assessment: Creating data rules","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","8000","8"]}}}],"nbHits":4,"page":0,"nbPages":1,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 8000-8","params":"query=ISO+8000-8&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":1}
359
+ http_version:
360
+ recorded_at: Tue, 26 Oct 2021 13:01:09 GMT
361
+ - request:
362
+ method: get
363
+ uri: https://www.iso.org/contents/data/standard/06/08/60805.html
364
+ body:
365
+ encoding: US-ASCII
366
+ string: ''
367
+ headers:
368
+ Accept-Encoding:
369
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
370
+ Accept:
371
+ - "*/*"
372
+ User-Agent:
373
+ - Ruby
374
+ Host:
375
+ - www.iso.org
376
+ response:
377
+ status:
378
+ code: 301
379
+ message: ''
380
+ headers:
381
+ Expires:
382
+ - Wed, 09 May 1979 05:30:00 GMT
383
+ Cache-Control:
384
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
385
+ Pragma:
386
+ - no-cache
387
+ Set-Cookie:
388
+ - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
389
+ Secure
390
+ - JSESSIONID=C15EF6FA1887ECECF9E8CB77EFAA0FB2; Path=/; Secure; HttpOnly
391
+ Location:
392
+ - "/standard/60805.html"
393
+ Content-Length:
394
+ - '0'
395
+ Date:
396
+ - Tue, 26 Oct 2021 08:01:09 CDT
397
+ Strict-Transport-Security:
398
+ - max-age=31536000; includeSubDomains
399
+ body:
400
+ encoding: UTF-8
401
+ string: ''
402
+ http_version:
403
+ recorded_at: Tue, 26 Oct 2021 13:01:10 GMT
404
+ - request:
405
+ method: get
406
+ uri: https://www.iso.org/standard/60805.html
407
+ body:
408
+ encoding: US-ASCII
409
+ string: ''
410
+ headers:
411
+ Accept-Encoding:
412
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
413
+ Accept:
414
+ - "*/*"
415
+ User-Agent:
416
+ - Ruby
417
+ Host:
418
+ - www.iso.org
419
+ response:
420
+ status:
421
+ code: 200
422
+ message: ''
423
+ headers:
424
+ Expires:
425
+ - Wed, 09 May 1979 05:30:00 GMT
426
+ Cache-Control:
427
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
428
+ Pragma:
429
+ - no-cache
430
+ Set-Cookie:
431
+ - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
432
+ Secure
433
+ - JSESSIONID=F37B09D0DBAA3B20E4A3FA7580C6188E; Path=/; Secure; HttpOnly
434
+ Vary:
435
+ - accept-encoding
436
+ Content-Type:
437
+ - text/html;charset=UTF-8
438
+ Transfer-Encoding:
439
+ - chunked
440
+ Date:
441
+ - Tue, 26 Oct 2021 13:01:11 GMT
442
+ Strict-Transport-Security:
443
+ - max-age=31536000; includeSubDomains
444
+ body:
445
+ encoding: ASCII-8BIT
446
+ string: !binary |-
447
+ <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 8000-8:2015 - Data quality — Part 8: Information and data quality: Concepts and measuring</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/60805.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1627457321310" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1627457321310"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1630493922153"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20210305" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/06/08/60805.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 8000-8:2015" />
    <meta property="og:title" content="ISO 8000-8:2015" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Data quality — Part 8: Information and data quality: Concepts and measuring" />
    <meta property="og:description" content="Data quality — Part 8: Information and data quality: Concepts and measuring" />
    <meta name="description" content="Data quality — Part 8: Information and data quality: Concepts and measuring" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/home/about-us/strategy-2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/60805.html">français</a></li><li><a href="/ru/standard/60805.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="60805 - ISO 8000-8:2015 - Data quality — Part 8: Information and data quality: Concepts and measuring"></span>

  <span class="hidden" id="itemReference">ISO 8000-8:2015</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">60805</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/01.html">01</a> >&nbsp;<a href="/en/ics/01.040.html">01.040</a> >&nbsp;<a href="/en/ics/01.040.25.html">01.040.25</a></div>
  

  <h1>ISO 8000-8:2015</h1>
  <h2 class="no-uppercase">Data quality — Part 8: Information and data quality: Concepts and measuring</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:60805:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>ISO 8000-8:2015 describes fundamental concepts of information and data quality, and how these concepts apply to quality management processes and quality management systems.</p>
<p>It also specifies prerequisites for measuring information and data quality when executed within quality management processes and quality management systems.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/06/08/60805.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2015-11</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 1
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 15
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/54158.html">ISO/TC 184/SC 4</a>
        </div>
        <div class="entry-title">Industrial data</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/01.040.25.html">
                01.040.25
            </a>
          </div>
          <div class="entry-title">Manufacturing engineering (Vocabularies)</div>
        </dd>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/25.040.40.html">
                25.040.40
            </a>
          </div>
          <div class="entry-title">Industrial process measurement and control</div>
        </dd>
      
    </dl>
  </li>
</ul>

      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">88</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub000000rDvB8AAK~a05b0000005WV2ZAAW~a0fb0000003V2frAAC~a0cb0000004lo0xAAA" lang="en" selected>
                      English
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">88</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Paper
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub000000rDvB8AAK~a05b0000005WV2eAAG~a0fb0000003V2fCAAS~a0cb0000004lo0IAAQ" lang="en" selected>
                      English
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">88</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Published</div>
                    
              <h5>ISO 8000-8:2015</h5>
                  <br/>A standard is reviewed every 5 years<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>90.60</strong> (Under review)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#10_99">
                              <span class="stage-code">10.99</span>
                              <span class="stage-date">2011-10-28</span>
                              <div class="stage-title">
                                New project approved
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#30_00">
                              <span class="stage-code">30.00</span>
                              <span class="stage-date">2013-03-21</span>
                              <div class="stage-title">
                                Committee draft (CD) registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_20">
                              <span class="stage-code">30.20</span>
                              <span class="stage-date">2013-03-22</span>
                              <div class="stage-title">
                                CD study/ballot initiated
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_60">
                              <span class="stage-code">30.60</span>
                              <span class="stage-date">2013-05-24</span>
                              <div class="stage-title">
                                Close of voting/ comment period
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">2013-05-28</span>
                              <div class="stage-title">
                                CD approved for registration as DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">2014-03-17</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">2014-05-19</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">2014-08-21</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2014-09-09</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2015-07-27</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2015-09-10</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2015-09-28</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2015-09-28</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2015-11-10</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2020-10-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2021-03-05</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_92">
                              <span class="stage-code">90.92</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard to be revised
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_99">
                              <span class="stage-code">90.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard proposed by TC or SC
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#95_99">
                              <span class="stage-code">95.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/01.html">01</a></li>
    
      <li><a href="/en/ics/01.040.html">01.040</a></li>
    
      <li><a href="/en/ics/01.040.25.html">01.040.25</a></li>
    <li>ISO 8000-8:2015</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
448
+ http_version:
449
+ recorded_at: Tue, 26 Oct 2021 13:01:12 GMT
450
+ - request:
451
+ method: post
452
+ uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
453
+ body:
454
+ encoding: UTF-8
455
+ string: '{"query":"ISO 9","hitsPerPage":100,"filters":"category:standard"}'
456
+ headers:
457
+ User-Agent:
458
+ - Algolia for Ruby (2.1.1), Ruby (3.0.2)
459
+ X-Algolia-Api-Key:
460
+ - dd1b9e1ab383f4d4817d29cd5e96d3f0
461
+ X-Algolia-Application-Id:
462
+ - JCL49WV5AR
463
+ Content-Type:
464
+ - application/json; charset=utf-8
465
+ Accept-Encoding:
466
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
467
+ Accept:
468
+ - "*/*"
469
+ Connection:
470
+ - keep-alive
471
+ Keep-Alive:
472
+ - '30'
473
+ response:
474
+ status:
475
+ code: 200
476
+ message: OK
477
+ headers:
478
+ Server:
479
+ - nginx
480
+ Date:
481
+ - Tue, 26 Oct 2021 13:01:13 GMT
482
+ Content-Type:
483
+ - application/json; charset=UTF-8
484
+ Transfer-Encoding:
485
+ - chunked
486
+ Connection:
487
+ - keep-alive
488
+ X-Alg-Pt:
489
+ - '6'
490
+ Accept-Encoding:
491
+ - deflate, gzip
492
+ Cache-Control:
493
+ - no-store
494
+ Access-Control-Allow-Origin:
495
+ - "*"
496
+ Timing-Allow-Origin:
497
+ - "*"
498
+ X-Content-Type-Options:
499
+ - nosniff
500
+ Strict-Transport-Security:
501
+ - max-age=31536000; includeSubDomains; preload
502
+ Content-Disposition:
503
+ - inline; filename=a.txt
504
+ body:
505
+ encoding: ASCII-8BIT
506
+ string: !binary |-
507
+ {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/75/67534","uuid":"d05a43dc-9869-4f2c-a8b4-62de04186689","title":"ISO 9022-9:2016 Optics and photonics — Environmental test methods — Part 9: Solar radiation and weathering","status":"Published","year":2021,"order":11,"text":"ISO 9022-9:2016 specifies the methods relating to the environmental tests of optical instruments including additional assemblies from other fields (e.g. mechanical, chemical and electronic devices), under equivalent conditions, for their ability to resist the effects of simulated solar radiation or laboratory weathering, which is a combination of simulated solar radiation, heat, and moisture. It is applicable to instruments that may be exposed to sunlight during operation or unsheltered storage on the earth's surface, or in the lower atmosphere. The purpose of testing is to investigate to what extent the optical, climatic, mechanical, chemical and electrical (including electrostatic) performance characteristics of the specimen are affected by solar radiation or weathering (solar radiation, heat, and moisture). ","objectID":"67534_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>022-<em>9</em>:2016 Optics and photonics — Environmental test methods — Part <em>9</em>: Solar radiation and weathering","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>022-<em>9</em>:2016 specifies the methods relating to the environmental tests of optical instruments including additional assemblies from other fields (e.g. mechanical, chemical and electronic devices), under equivalent conditions, for their ability to resist the effects of simulated solar radiation or laboratory weathering, which is a combination of simulated solar radiation, heat, and moisture. It is applicable to instruments that may be exposed to sunlight during operation or unsheltered storage on the earth's surface, or in the lower atmosphere. The purpose of testing is to investigate to what extent the optical, climatic, mechanical, chemical and electrical (including electrostatic) performance characteristics of the specimen are affected by solar radiation or weathering (solar radiation, heat, and moisture). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/13/41375","uuid":"359ee322-99f3-462e-a820-01bdc56236a5","title":"ISO 9073-9:2008 Textiles — Test methods for nonwovens — Part 9: Determination of drapability including drape coefficient","status":"Published","year":2021,"order":11,"text":"ISO 9073-9:2008 specifies a test method that is used to determine the drape coefficient of fabrics (nonwovens, wovens and knitted fabrics). ","objectID":"41375_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>073-<em>9</em>:2008 Textiles — Test methods for nonwovens — Part <em>9</em>: Determination of drapability including drape coefficient","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>073-<em>9</em>:2008 specifies a test method that is used to determine the drape coefficient of fabrics (nonwovens, wovens and knitted fabrics). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/77/37711","uuid":"f0105cba-6608-4563-baf2-f7a1502dbb5f","title":"ISO 9100-9:2005 Glass containers — Vacuum lug finishes — Part 9: 63, 66 and 70 deep","status":"Published","year":2021,"order":11,"text":"ISO 9100-9:2005 specifies the dimensions of vacuum lug finishes with nominal sizes of 63, 66 and 70 mm deep for wide-mouth glass containers. ","objectID":"37711_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>100-<em>9</em>:2005 Glass containers — Vacuum lug finishes — Part <em>9</em>: 63, 66 and 70 deep","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>100-<em>9</em>:2005 specifies the dimensions of vacuum lug finishes with nominal sizes of 63, 66 and 70 mm deep for wide-mouth glass containers. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/10/81061","uuid":"4ba6d0ae-98e5-4a8c-9d01-869d4bc01095","title":"ISO 9455-9:2020 Soft soldering fluxes — Test methods — Part 9: Determination of ammonia content","status":"Published","year":2020,"order":11,"text":"This document specifies a distillation method for the determination of the ammonia content of solid, paste or liquid fluxes. The method is applicable to fluxes of class 311 and 321 only, as defined in ISO 9454‑1. ","objectID":"81061_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>455-<em>9</em>:2020 Soft soldering fluxes — Test methods — Part <em>9</em>: Determination of ammonia content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies a distillation method for the determination of the ammonia content of solid, paste or liquid fluxes. The method is applicable to fluxes of class 311 and 321 only, as defined in <em>ISO</em> <em>9</em>454‑1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/53/5389","uuid":"acb6e327-bd19-4ecc-83af-759bd30e83cf","title":"ISO 962:1974 Information processing — Implementation of the 7- bit coded character set and its 7- bit and 8-bit extensions on 9- track 12,7 mm (0.5 in) magnetic tape","status":"Published","year":2020,"order":11,"text":"Specifies the representation of the 7-bit-code and its 7-bit and 8-bit extensions on an 9-track magnetic tape with a width of 12,7 mm (0,5 in). ","objectID":"5389_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>62:1974 Information processing — Implementation of the 7- bit coded character set and its 7- bit and 8-bit extensions on <em>9</em>- track 12,7 mm (0.5 in) magnetic tape","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Specifies the representation of the 7-bit-code and its 7-bit and 8-bit extensions on an <em>9</em>-track magnetic tape with a width of 12,7 mm (0,5 in). ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/34/63462","uuid":"27f2a546-fad6-4890-9807-2ed5901e6a28","title":"ISO 9241-220:2019 Ergonomics of human-system interaction — Part 220: Processes for enabling, executing and assessing human-centred design within organizations","status":"Published","year":2019,"order":11,"text":"This document describes the processes and specifies the outcomes by which human-centred design (HCD) is carried out within organizations. Human-centred design aims to meet requirements for human-centred quality (see Annex E) throughout the life cycle of interactive systems. The processes are described from the viewpoint of those responsible for the analysis, design and evaluation of the human use of interactive systems. The process descriptions include the purpose, benefits, outcomes, typical activities and work products for each process, and are for use in the specification, implementation, assessment and improvement of the activities used for human-centred design and operation in any type of system life cycle. They can also provide the basis for professional development and certification. The processes are associated with the domains of ergonomics/human factors, human?computer interaction, usability and user experience. This document does not include specific methods for human-centred design, nor does it describe processes for organizational redesign. The scope of this document does not include other aspects of ergonomics, which include the design of organizations as well as systems for human use, and which extend beyond the domain of design; for example in the forensic analysis of the causes of accidents and in the generation of data and methods of measurement. NOTE 1    ISO/TS 18152 is a related standard with a broader scope than this document. It includes the organizational processes for the identification and handling of issues related to both users and other stakeholders. The intended application of this document is computer-based interactive systems. While the processes apply to interactive systems that deliver services, they do not cover the design of those services. The relevant aspects of the processes can also be applied to simple or non-computer?based interactive systems. NOTE 2    Human-centred design concentrates on the human-centred aspects of design and not on other aspects of design such as mechanical construction, programming or the basic design of services. The process descriptions in this document provide the basis for a rigorous assessment of an enterprise's capability to carry out human-centred processes in compliance with the ISO/IEC 33000 family of standards. This document is intended for use by organizations that want to address and improve their treatment of human-centred design of either their internal systems or the products and services they provide, and the procurement of systems and parts of systems. The processes can be applied by small- and medium-sized enterprises as well as by large organizations. Copyright release for the process descriptions Users of this document may freely reproduce the process descriptions contained in Clause 9 as part of any process assessment model, or as part of any demonstration of compatibility with this document, so that it can be used for its intended purpose. ","objectID":"63462_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>241-220:2019 Ergonomics of human-system interaction — Part 220: Processes for enabling, executing and assessing human-centred design within organizations","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document describes the processes and specifies the outcomes by which human-centred design (HCD) is carried out within organizations. Human-centred design aims to meet requirements for human-centred quality (see Annex E) throughout the life cycle of interactive systems. The processes are described from the viewpoint of those responsible for the analysis, design and evaluation of the human use of interactive systems. The process descriptions include the purpose, benefits, outcomes, typical activities and work products for each process, and are for use in the specification, implementation, assessment and improvement of the activities used for human-centred design and operation in any type of system life cycle. They can also provide the basis for professional development and certification. The processes are associated with the domains of ergonomics/human factors, human?computer interaction, usability and user experience. This document does not include specific methods for human-centred design, nor does it describe processes for organizational redesign. The scope of this document does not include other aspects of ergonomics, which include the design of organizations as well as systems for human use, and which extend beyond the domain of design; for example in the forensic analysis of the causes of accidents and in the generation of data and methods of measurement. NOTE 1    <em>ISO</em>/TS 18152 is a related standard with a broader scope than this document. It includes the organizational processes for the identification and handling of issues related to both users and other stakeholders. The intended application of this document is computer-based interactive systems. While the processes apply to interactive systems that deliver services, they do not cover the design of those services. The relevant aspects of the processes can also be applied to simple or non-computer?based interactive systems. NOTE 2    Human-centred design concentrates on the human-centred aspects of design and not on other aspects of design such as mechanical construction, programming or the basic design of services. The process descriptions in this document provide the basis for a rigorous assessment of an enterprise's capability to carry out human-centred processes in compliance with the <em>ISO</em>/IEC 33000 family of standards. This document is intended for use by organizations that want to address and improve their treatment of human-centred design of either their internal systems or the products and services they provide, and the procurement of systems and parts of systems. The processes can be applied by small- and medium-sized enterprises as well as by large organizations. Copyright release for the process descriptions Users of this document may freely reproduce the process descriptions contained in Clause <em>9</em> as part of any process assessment model, or as part of any demonstration of compatibility with this document, so that it can be used for its intended purpose. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/07/60715","uuid":"9286d5fd-fdab-488a-b99b-6744fc68cc63","title":"ISO 9448-9:2013 Tools for pressing — Guide bushes — Part 9: Form B, ball cage bushes, plain, type 2","status":"Published","year":2019,"order":11,"text":"ISO 9448-9:2013 specifies the main dimensions and tolerances, in millimetres, of guide bushes of form B, plain ball cage bushes, type 2, intended for use in press tools and to be mounted in the clamp plate by means of interference fit. It gives guidance on the materials, and specifies the hardness and the designation of bushes in accordance with ISO 9448-9:2013. ","objectID":"60715_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>448-<em>9</em>:2013 Tools for pressing — Guide bushes — Part <em>9</em>: Form B, ball cage bushes, plain, type 2","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>448-<em>9</em>:2013 specifies the main dimensions and tolerances, in millimetres, of guide bushes of form B, plain ball cage bushes, type 2, intended for use in press tools and to be mounted in the clamp plate by means of interference fit. It gives guidance on the materials, and specifies the hardness and the designation of bushes in accordance with <em>ISO</em> <em>9</em>448-<em>9</em>:2013. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/50/35040","uuid":"bcf7a05a-3d21-4d12-900a-50e71c1e1922","title":"ISO 9735-9:2002 Electronic data interchange for administration, commerce and transport (EDIFACT) — Application level syntax rules (Syntax version number: 4, Syntax release number: 1) — Part 9: Security key and certificate management message (message type- KEYMAN)","status":"Published","year":2019,"order":11,"text":"This part of ISO 9735 for batch EDIFACT security defines the security key and certificate management message KEYMAN. ","objectID":"35040_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>735-<em>9</em>:2002 Electronic data interchange for administration, commerce and transport (EDIFACT) — Application level syntax rules (Syntax version number: 4, Syntax release number: 1) — Part <em>9</em>: Security key and certificate management message (message type- KEYMAN)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This part of <em>ISO</em> <em>9</em>735 for batch EDIFACT security defines the security key and certificate management message KEYMAN. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/35/3589","uuid":"844bb0c5-0351-405a-b4ce-462bb1e7c985","title":"ISO 9:1995 Information and documentation — Transliteration of Cyrillic characters into Latin characters — Slavic and non-Slavic languages","status":"Published","year":2017,"order":11,"text":"Cancels and replaces the first edition (1986). Establishes a system for the transliteration into Latin characters of Cyrillic characters constituting the alphabets of Slavic and non-Slavic languages. Table 3 includes in a single sequence, listed in the Cyrillic alphabetic order, the 118 single or diacritic-carrying characters that appear in one or another of the considered alphabets. ","objectID":"3589_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>:1995 Information and documentation — Transliteration of Cyrillic characters into Latin characters — Slavic and non-Slavic languages","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Cancels and replaces the first edition (1986). Establishes a system for the transliteration into Latin characters of Cyrillic characters constituting the alphabets of Slavic and non-Slavic languages. Table 3 includes in a single sequence, listed in the Cyrillic alphabetic order, the 118 single or diacritic-carrying characters that appear in one or another of the considered alphabets. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/78/17846","uuid":"0f0a7cc8-7b9c-415c-bd77-6ebe4e2c2351","title":"ISO 9949-2:1993 Urine absorbing aids — Vocabulary — Part 2: Products","status":"Withdrawn","year":2021,"order":100,"text":"Defines 9 terms used in the field of urine absorbing aids and comprises the vocabulary for products. The terms used for products do not, individually or collectively, define or recommend specific designs, styles or constructions. ","objectID":"17846_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>949-2:1993 Urine absorbing aids — Vocabulary — Part 2: Products","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Defines <em>9</em> terms used in the field of urine absorbing aids and comprises the vocabulary for products. The terms used for products do not, individually or collectively, define or recommend specific designs, styles or constructions. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/71/17176","uuid":"028ec193-3eb9-453b-9e80-54f08f49b5cb","title":"ISO 9455-9:1993 Soft soldering fluxes — Test methods — Part 9: Determination of ammonia content","status":"Withdrawn","year":2020,"order":100,"text":"The principle of the method specified is to distil a prepared flux solution with sodium hydroxide to expel the ammonia present in the flux, to pass the resulting distillate into a standard sulfuric acid solution, to titrate the excess acid with sodium hydroxide solution and to calculate the ammonia content of the flux. Applies to fluxes of class 3.1.1 only, as defined in ISO 9454-1. ","objectID":"17176_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>455-<em>9</em>:1993 Soft soldering fluxes — Test methods — Part <em>9</em>: Determination of ammonia content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"The principle of the method specified is to distil a prepared flux solution with sodium hydroxide to expel the ammonia present in the flux, to pass the resulting distillate into a standard sulfuric acid solution, to titrate the excess acid with sodium hydroxide solution and to calculate the ammonia content of the flux. Applies to fluxes of class 3.1.1 only, as defined in <em>ISO</em> <em>9</em>454-1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/65/16574","uuid":"ed9ae1b6-72f9-4e74-bf42-827d29f7b200","title":"ISO 9022-9:1994 Optics and optical instruments — Environmental test methods — Part 9: Solar radiation","status":"Withdrawn","year":2016,"order":100,"text":"Specifies methods for the testing of optical instruments and instruments containing optical components, under equivalent conditions, for their ability to resist the effects of simulated solar radiation. Is applicable to instruments that may be exposed to sunlight during operation or unsheltered storage on the earth's surface, or in the lower atmosphere. The purpose of testing is to investigate to what extent the optical, thermal, mechanical, chemical and electrical performance characteristics are affected by solar radiation. ","objectID":"16574_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>022-<em>9</em>:1994 Optics and optical instruments — Environmental test methods — Part <em>9</em>: Solar radiation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Specifies methods for the testing of optical instruments and instruments containing optical components, under equivalent conditions, for their ability to resist the effects of simulated solar radiation. Is applicable to instruments that may be exposed to sunlight during operation or unsheltered storage on the earth's surface, or in the lower atmosphere. The purpose of testing is to investigate to what extent the optical, thermal, mechanical, chemical and electrical performance characteristics are affected by solar radiation. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/72/17206","uuid":"a74d01a7-8dc7-45b4-afc3-7aef5fff8f79","title":"ISO 9477:1992 High strength cast steels for general engineering and structural purposes","status":"Withdrawn","year":2015,"order":100,"text":"Specifies requirements for four grades of heat-treated cast carbon and alloy steels for service at ambient temperature. Where castings are produced by welding together component parts, it does not cover the welding process or the properties of the weldment. Properties at other temperatures may be agreed on through the use of the supplementary requirements in 9.4.1 or 9.4.4 of ISO 4990:1986. ","objectID":"17206_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>477:1992 High strength cast steels for general engineering and structural purposes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Specifies requirements for four grades of heat-treated cast carbon and alloy steels for service at ambient temperature. Where castings are produced by welding together component parts, it does not cover the welding process or the properties of the weldment. Properties at other temperatures may be agreed on through the use of the supplementary requirements in <em>9</em>.4.1 or <em>9</em>.4.4 of <em>ISO</em> 4990:1986. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/03/00/30030","uuid":"ba1bd36a-b5d5-49f0-b164-5bd8449ce353","title":"ISO 9241-9:2000 Ergonomic requirements for office work with visual display terminals (VDTs) — Part 9: Requirements for non-keyboard input devices","status":"Withdrawn","year":2012,"order":100,"objectID":"30030_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>241-<em>9</em>:2000 Ergonomic requirements for office work with visual display terminals (VDTs) — Part <em>9</em>: Requirements for non-keyboard input devices","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/78/17827","uuid":"4ee16586-8d84-42ba-ae1a-e32fcdfcbf87","title":"ISO 9933:1995 Products in fibre-reinforced cement — Long corrugated or asymmetrical section sheets and fittings for roofing and cladding","status":"Withdrawn","year":2011,"order":100,"text":"Lays down the technical characteristics of straight fibre-cement profiled sheets, of more than 0,9 m length, and their fibre-cement fittings used as roofing and cladding materials. Also specifies tests for checking these characteristics as well as marking and conditions of acceptance. Does not apply to asbestos-cement corrugated or profiled sheets, nor to short fibre-cement sheets. ","objectID":"17827_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>933:1995 Products in fibre-reinforced cement — Long corrugated or asymmetrical section sheets and fittings for roofing and cladding","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Lays down the technical characteristics of straight fibre-cement profiled sheets, of more than 0,<em>9</em> m length, and their fibre-cement fittings used as roofing and cladding materials. Also specifies tests for checking these characteristics as well as marking and conditions of acceptance. Does not apply to asbestos-cement corrugated or profiled sheets, nor to short fibre-cement sheets. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/74/17410","uuid":"2f212355-a1a1-400e-b448-75dfde315c0e","title":"ISO 9598:1989 Seamless steel tubes for pressure purposes — Full peripheral magnetic transducer/flux leakage testing of ferromagnetic steel tubes for the detection of transverse imperfections","status":"Withdrawn","year":2011,"order":100,"text":"Applicable to the inspection of tubes with an outside diameter greater than or equal to 9 mm. Specifies general requirements, method of test, reference standards, reference notches, equipment calibration and checking, acceptance and test report. Annex A gives notes on limitations of the magnetic transducer/flux leakage technique. ","objectID":"17410_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>598:1989 Seamless steel tubes for pressure purposes — Full peripheral magnetic transducer/flux leakage testing of ferromagnetic steel tubes for the detection of transverse imperfections","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Applicable to the inspection of tubes with an outside diameter greater than or equal to <em>9</em> mm. Specifies general requirements, method of test, reference standards, reference notches, equipment calibration and checking, acceptance and test report. Annex A gives notes on limitations of the magnetic transducer/flux leakage technique. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/71/17100","uuid":"536e9393-e090-4e7c-99c6-c58cb4fc3c66","title":"ISO 9402:1989 Seamless and welded (except submerged arc-welded) steel tubes for pressure purposes — Full peripheral magnetic transducer/flux leakage testing of ferromagnetic steel tubes for the detection of longitudinal imperfections","status":"Withdrawn","year":2011,"order":100,"text":"Applicable to the inspection of tubes with an outside diameter greater than or equal to 9 mm. Specifies general requirements, method of test, reference standards, reference notches, equipment calibration and checking, acceptance and test report. Annex A gives notes on limitations of the magnetic transducer/flux leakage technique. ","objectID":"17100_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>402:1989 Seamless and welded (except submerged arc-welded) steel tubes for pressure purposes — Full peripheral magnetic transducer/flux leakage testing of ferromagnetic steel tubes for the detection of longitudinal imperfections","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Applicable to the inspection of tubes with an outside diameter greater than or equal to <em>9</em> mm. Specifies general requirements, method of test, reference standards, reference notches, equipment calibration and checking, acceptance and test report. Annex A gives notes on limitations of the magnetic transducer/flux leakage technique. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/69/16962","uuid":"6489a78a-2c98-4266-95fc-10f6f6b87bf1","title":"ISO 9305:1989 Seamless steel tubes for pressure purposes — Full peripheral ultrasonic testing for the detection of transverse imperfections","status":"Withdrawn","year":2011,"order":100,"text":"Applicable to the inspection of tubes with an outside diameter greater than or equal to 9 mm. Specifies general requirements, method of test, reference notches, equipment calibration and checking, acceptance and test report. ","objectID":"16962_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>305:1989 Seamless steel tubes for pressure purposes — Full peripheral ultrasonic testing for the detection of transverse imperfections","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Applicable to the inspection of tubes with an outside diameter greater than or equal to <em>9</em> mm. Specifies general requirements, method of test, reference notches, equipment calibration and checking, acceptance and test report. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/69/16960","uuid":"2b5190be-388c-40fb-8dc0-ed9b7fd1b51c","title":"ISO 9303:1989 Seamless and welded (except submerged arc-welded) steel tubes for pressure purposes — Full peripheral ultrasonic testing for the detection of longitudinal imperfections","status":"Withdrawn","year":2011,"order":100,"text":"Is applicable to the inspection of tubes with an outside diameter greater than or equal to 9 mm, and with an outside diameter-to-thickness ratio greater than or equal to 5. Specifies general requirements, method of test, reference standards, reference notch, equipment calibration and checking, acceptance and test report. Annex A contains information concerning testing of tubes having an outside diameter-to-thickness ratio less than 5. ","objectID":"16960_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>303:1989 Seamless and welded (except submerged arc-welded) steel tubes for pressure purposes — Full peripheral ultrasonic testing for the detection of longitudinal imperfections","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Is applicable to the inspection of tubes with an outside diameter greater than or equal to <em>9</em> mm, and with an outside diameter-to-thickness ratio greater than or equal to 5. Specifies general requirements, method of test, reference standards, reference notch, equipment calibration and checking, acceptance and test report. Annex A contains information concerning testing of tubes having an outside diameter-to-thickness ratio less than 5. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/34/23471","uuid":"e37002e8-6320-46d9-8670-212deec8e56e","title":"ISO 9073-9:1995 Textiles — Test methods for nonwovens — Part 9: Determination of drape coefficient","status":"Withdrawn","year":2008,"order":100,"text":"Specifies a method for determining the drape coeffizient of nonwovens. ","objectID":"23471_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>073-<em>9</em>:1995 Textiles — Test methods for nonwovens — Part <em>9</em>: Determination of drape coefficient","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Specifies a method for determining the drape coeffizient of nonwovens. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/01/71/17159","uuid":"07978ad6-a1b5-48f8-b0a6-06060f2907a2","title":"ISO 9448-9:1992 Tools for pressing — Guide bushes — Part 9: Form B, ball cage bushes, plain, type 2","status":"Withdrawn","year":2006,"order":100,"text":"Specifies the main dimensions and tolerances, gives guidance on materials, and specifies the hardness and the designation. ","objectID":"17159_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>448-<em>9</em>:1992 Tools for pressing — Guide bushes — Part <em>9</em>: Form B, ball cage bushes, plain, type 2","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Specifies the main dimensions and tolerances, gives guidance on materials, and specifies the hardness and the designation. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/02/90/29066","uuid":"96247d7b-96ba-4650-a14e-84fc64f31138","title":"ISO 9735-9:1999 Electronic data interchange for administration, commerce and transport (EDIFACT) — Application level syntax rules (Syntax version number: 4) — Part 9: Security key and certificate management message (message type- KEYMAN)","status":"Withdrawn","year":2002,"order":100,"objectID":"29066_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>735-<em>9</em>:1999 Electronic data interchange for administration, commerce and transport (EDIFACT) — Application level syntax rules (Syntax version number: 4) — Part <em>9</em>: Security key and certificate management message (message type- KEYMAN)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/35/3588","uuid":"fccfd97c-1d6b-466d-8edf-9be649257df2","title":"ISO 9:1986 Documentation — Transliteration of Slavic Cyrillic characters into Latin characters","status":"Withdrawn","year":1995,"order":100,"objectID":"3588_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>:1986 Documentation — Transliteration of Slavic Cyrillic characters into Latin characters","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/24/82447","uuid":"18b5cd46-c2b8-4aa1-8d48-2f21e1b4ff43","title":"ISO 9026:2021 Raw rubber or unvulcanized compounds — Determination of green strength","status":"Published","year":2021,"order":11,"text":"This document specifies a method for the determination of the green strength of raw rubber or unvulcanized rubber compounds using a tensile stress-strain test, the test pieces being prepared following standard test conditions or cut from calendered sheets. ","objectID":"82447_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>026:2021 Raw rubber or unvulcanized compounds — Determination of green strength","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies a method for the determination of the green strength of raw rubber or unvulcanized rubber compounds using a tensile stress-strain test, the test pieces being prepared following standard test conditions or cut from calendered sheets. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/22/82249","uuid":"631b1679-339a-485b-85ae-cfb701cf404f","title":"ISO 9982:2021 Belt drives — Pulleys and V-ribbed belts for industrial applications — PH, PJ, PK, PL and PM profiles: dimensions","status":"Published","year":2021,"order":11,"text":"This document specifies the principal dimensional characteristics of V-ribbed pulley groove profiles, together with the corresponding endless V-ribbed belts, of PH, PJ, PK, PL and PM profiles which are used for general industrial applications except elastic belts. The PK belt was originally established for automotive accessory drive applications and ISO 9981 deals specifically with that particular field. ","objectID":"82249_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>982:2021 Belt drives — Pulleys and V-ribbed belts for industrial applications — PH, PJ, PK, PL and PM profiles: dimensions","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies the principal dimensional characteristics of V-ribbed pulley groove profiles, together with the corresponding endless V-ribbed belts, of PH, PJ, PK, PL and PM profiles which are used for general industrial applications except elastic belts. The PK belt was originally established for automotive accessory drive applications and <em>ISO</em> <em>9</em>981 deals specifically with that particular field. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/11/81192","uuid":"80e1d912-d721-4b54-87e8-983208f20556","title":"ISO 9624:2019/Amd 1:2021 Thermoplastics piping systems for fluids under pressure — Flange adapters and loose backing flanges — Mating dimensions — Amendment 1","status":"Published","year":2021,"order":11,"objectID":"81192_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>624:2019/Amd 1:2021 Thermoplastics piping systems for fluids under pressure — Flange adapters and loose backing flanges — Mating dimensions — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/09/80924","uuid":"ac996dce-b574-49d1-838f-1c9c2c5f256d","title":"ISO 965-5:1998/Amd 1:2021 ISO general purpose metric screw threads — Tolerances — Part 5: Limits of sizes for internal screw threads to mate with hot-dip galvanized external screw threads with maximum size of tolerance position h before galvanizing — Amendment 1","status":"Published","year":2021,"order":11,"objectID":"80924_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>65-5:1998/Amd 1:2021 <em>ISO</em> general purpose metric screw threads — Tolerances — Part 5: Limits of sizes for internal screw threads to mate with hot-dip galvanized external screw threads with maximum size of tolerance position h before galvanizing — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/09/80923","uuid":"0dfb082c-a998-4b93-aa3e-7474168e4790","title":"ISO 965-4:2021 ISO general purpose metric screw threads — Tolerances — Part 4: Limits of sizes for hot-dip galvanized external screw threads to mate with internal screw threads tapped with tolerance position H or G after galvanizing","status":"Published","year":2021,"order":11,"text":"This document specifies limit deviations and limits of sizes for the pitch and crest diameters of the hot-dip galvanized metric external screw threads conforming to the coarse thread series of ISO 262 (from M8 to M64) having a basic profile according to ISO 68-1. This document is applicable to the hot-dip galvanized metric external screw threads to mate with the internal screw threads tapped with tolerance position H or G after galvanizing. ","objectID":"80923_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>65-4:2021 <em>ISO</em> general purpose metric screw threads — Tolerances — Part 4: Limits of sizes for hot-dip galvanized external screw threads to mate with internal screw threads tapped with tolerance position H or G after galvanizing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies limit deviations and limits of sizes for the pitch and crest diameters of the hot-dip galvanized metric external screw threads conforming to the coarse thread series of <em>ISO</em> 262 (from M8 to M64) having a basic profile according to <em>ISO</em> 68-1. This document is applicable to the hot-dip galvanized metric external screw threads to mate with the internal screw threads tapped with tolerance position H or G after galvanizing. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/09/80922","uuid":"f567130e-10f4-4318-8e0b-bd431ee75fca","title":"ISO 965-3:2021 ISO general purpose metric screw threads — Tolerances — Part 3: Limit deviations for screw threads","status":"Published","year":2021,"order":11,"text":"This document specifies limit deviations for pitch and crest diameters for ISO general purpose metric screw threads (M) conforming to ISO 261 having basic profile in accordance with ISO 68-1. The limit deviations specified are derived from the fundamental deviations and tolerances specified in ISO 965-1. This document is applicable to ISO general purpose metric screw threads with the recommended tolerance classes. ","objectID":"80922_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>65-3:2021 <em>ISO</em> general purpose metric screw threads — Tolerances — Part 3: Limit deviations for screw threads","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies limit deviations for pitch and crest diameters for <em>ISO</em> general purpose metric screw threads (M) conforming to <em>ISO</em> 261 having basic profile in accordance with <em>ISO</em> 68-1. The limit deviations specified are derived from the fundamental deviations and tolerances specified in <em>ISO</em> <em>9</em>65-1. This document is applicable to <em>ISO</em> general purpose metric screw threads with the recommended tolerance classes. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/09/80921","uuid":"b1a1d38c-acf0-41b6-af04-52cfab5f6cd3","title":"ISO 965-2:1998/Amd 1:2021 ISO general purpose metric screw threads — Tolerances — Part 2: Limits of sizes for general purpose external and internal screw threads — Medium quality — Amendment 1","status":"Published","year":2021,"order":11,"objectID":"80921_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>65-2:1998/Amd 1:2021 <em>ISO</em> general purpose metric screw threads — Tolerances — Part 2: Limits of sizes for general purpose external and internal screw threads — Medium quality — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/09/80920","uuid":"49494e2b-b7fe-4ad3-9cd8-acb09b0050d7","title":"ISO 965-1:2013/Amd 1:2021 ISO general purpose metric screw threads — Tolerances — Part 1: Principles and basic data — Amendment 1","status":"Published","year":2021,"order":11,"objectID":"80920_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>65-1:2013/Amd 1:2021 <em>ISO</em> general purpose metric screw threads — Tolerances — Part 1: Principles and basic data — Amendment 1","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/04/80475","uuid":"2259dc85-965b-41dc-9898-245a3ff6c843","title":"ISO 9211-7:2021 Optics and photonics — Optical coatings — Part 7: Minimum requirements for neutral beam splitter coatings","status":"Published","year":2021,"order":11,"text":"This document specifies minimum requirements on the optical effects and the mechanical, chemical and environmental properties of neutral beam splitter coatings. This document applies to neutral beam splitter coatings for optical applications. Thereby the user is able to rely on defined numerical data while the manufacturer of thin films has the choice for the materials and production method. ","objectID":"80475_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>211-7:2021 Optics and photonics — Optical coatings — Part 7: Minimum requirements for neutral beam splitter coatings","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies minimum requirements on the optical effects and the mechanical, chemical and environmental properties of neutral beam splitter coatings. This document applies to neutral beam splitter coatings for optical applications. Thereby the user is able to rely on defined numerical data while the manufacturer of thin films has the choice for the materials and production method. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/03/80315","uuid":"32542914-9781-4913-911d-04a66f7afe92","title":"ISO 9932:2021 Paper and board — Determination of water vapour transmission rate of sheet materials — Dynamic sweep and static gas methods","status":"Published","year":2021,"order":11,"text":"This document describes general test methods for determining the water vapour transmission rate of sheet materials by means of a dynamic gas method or a static gas method. Depending on the method and specific apparatus employed, materials up to 38 mm thick and with water vapour transmission rates in the range from 0,05 g/(m 2 ·d) to 65 g/(m 2 ·d) can be tested. The basis of the function of the instrumental techniques is briefly described. Advice on calibration is given in Annex B. ","objectID":"80315_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>932:2021 Paper and board — Determination of water vapour transmission rate of sheet materials — Dynamic sweep and static gas methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document describes general test methods for determining the water vapour transmission rate of sheet materials by means of a dynamic gas method or a static gas method. Depending on the method and specific apparatus employed, materials up to 38 mm thick and with water vapour transmission rates in the range from 0,05 g/(m 2 ·d) to 65 g/(m 2 ·d) can be tested. The basis of the function of the instrumental techniques is briefly described. Advice on calibration is given in Annex B. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/95/79550","uuid":"5e96307c-53e6-461c-b6d3-120bef5aaccb","title":"ISO 9869-2:2018/Amd 1:2021 Thermal insulation — Building elements — In-situ measurement of thermal resistance and thermal transmittance — Part 2: Infrared method for frame structure dwelling — Amendment 1: Example of calculation of uncertainty analysis","status":"Published","year":2021,"order":11,"objectID":"79550_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>869-2:2018/Amd 1:2021 Thermal insulation — Building elements — In-situ measurement of thermal resistance and thermal transmittance — Part 2: Infrared method for frame structure dwelling — Amendment 1: Example of calculation of uncertainty analysis","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/91/79154","uuid":"4f42cfbd-d1f8-43c6-816e-1ca52884c7e6","title":"ISO 9286:2021 Abrasive grains and crude — Chemical analysis of silicon carbide","status":"Published","year":2021,"order":11,"text":"This document specifies the chemical analysis of silicon-carbide-based abrasive grains and crudes. It is applicable for the determination of the surface impurities of abrasives grains and the determination of the SiC content of crushed crude when the silicon carbide content is greater than 95 % (mass fraction). ","objectID":"79154_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>286:2021 Abrasive grains and crude — Chemical analysis of silicon carbide","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies the chemical analysis of silicon-carbide-based abrasive grains and crudes. It is applicable for the determination of the surface impurities of abrasives grains and the determination of the SiC content of crushed crude when the silicon carbide content is greater than <em>9</em>5 % (mass fraction). ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/91/79120","uuid":"3893dc13-d590-4d60-bc52-f88219a3bfc7","title":"ISO 9182-5:2020 Tools for pressing — Guide pillars — Part 5: Type D, end-locking pillars with flange","status":"Published","year":2021,"order":11,"text":"This document specifies the dimensions and tolerances of guide pillars, type D, end-locking pillar with flange, intended for use in press tools. It gives guidance on the materials and specifies the hardness and the designation of guide pillars which meet the requirements of this document. ","objectID":"79120_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>182-5:2020 Tools for pressing — Guide pillars — Part 5: Type D, end-locking pillars with flange","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies the dimensions and tolerances of guide pillars, type D, end-locking pillar with flange, intended for use in press tools. It gives guidance on the materials and specifies the hardness and the designation of guide pillars which meet the requirements of this document. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/91/79119","uuid":"35afe997-b059-4a57-b383-daf2a98f64c7","title":"ISO 9182-4:2020 Tools for pressing — Guide pillars — Part 4: Type C, pillars with taper lead and bush","status":"Published","year":2021,"order":11,"text":"This document specifies the dimensions and tolerances of guide pillars, type C, with taper lead and bush, intended for use in press tools. It gives guidance on the materials and specifies the hardness and the designation of guide pillars which meet the requirements of this document. ","objectID":"79119_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>182-4:2020 Tools for pressing — Guide pillars — Part 4: Type C, pillars with taper lead and bush","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies the dimensions and tolerances of guide pillars, type C, with taper lead and bush, intended for use in press tools. It gives guidance on the materials and specifies the hardness and the designation of guide pillars which meet the requirements of this document. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/91/79118","uuid":"5c7b0436-f02b-454a-ae15-00930faf583d","title":"ISO 9182-3:2020 Tools for pressing — Guide pillars — Part 3: Type B, end-locking pillars","status":"Published","year":2021,"order":11,"text":"This document specifies the dimensions and tolerances of guide pillars, type B, intended for use in press tools. These guide pillars can be end-locking, type B1 (see Figure 1), or end-locking with lubrication grooves, type B2 (see Figure 2). It gives guidance on the materials and specifies the hardness and the designation of guide pillars which meet the requirements of this document. ","objectID":"79118_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>182-3:2020 Tools for pressing — Guide pillars — Part 3: Type B, end-locking pillars","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies the dimensions and tolerances of guide pillars, type B, intended for use in press tools. These guide pillars can be end-locking, type B1 (see Figure 1), or end-locking with lubrication grooves, type B2 (see Figure 2). It gives guidance on the materials and specifies the hardness and the designation of guide pillars which meet the requirements of this document. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/89/78908","uuid":"68ae7fd1-d419-485e-88e4-424fc36eb59e","title":"ISO 9235:2021 Aromatic natural raw materials — Vocabulary","status":"Published","year":2021,"order":11,"text":"This document specifies the terms and definitions relating to aromatic natural raw materials. ","objectID":"78908_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>235:2021 Aromatic natural raw materials — Vocabulary","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies the terms and definitions relating to aromatic natural raw materials. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/83/78362","uuid":"c0de989d-f62f-420b-b9ad-978872e91cdf","title":"ISO 9073-4:2021 Nonwovens — Test methods — Part 4: Determination of tear resistance by the trapezoid procedure","status":"Published","year":2021,"order":11,"text":"This document specifies a method for the determination of tear resistance of nonwovens by the trapezoid method. This document applies to nonwovens. ","objectID":"78362_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>073-4:2021 Nonwovens — Test methods — Part 4: Determination of tear resistance by the trapezoid procedure","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies a method for the determination of tear resistance of nonwovens by the trapezoid method. This document applies to nonwovens. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/72/77221","uuid":"072593b8-a902-4bee-8f29-b5499003f44d","title":"ISO 9046:2021 Building and civil engineering sealants — Determination of adhesion/cohesion properties at constant temperature","status":"Published","year":2021,"order":11,"text":"The document specifies a method for the determination of the adhesion/cohesion properties of sealants with predominantly plastic behaviour which are used in buildings and civil engineering works. ","objectID":"77221_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>046:2021 Building and civil engineering sealants — Determination of adhesion/cohesion properties at constant temperature","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"The document specifies a method for the determination of the adhesion/cohesion properties of sealants with predominantly plastic behaviour which are used in buildings and civil engineering works. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/70/77086","uuid":"01deaffa-5b38-4335-8c4b-8fc6c67306fd","title":"ISO 9038:2021 Determination of sustained combustibility of liquids","status":"Published","year":2021,"order":11,"text":"This document specifies a procedure, at temperatures up to 100 °C, to determine whether a liquid product, that would be classified as “flammable” by virtue of its flash point, sustains combustion at the temperature(s) specified e.g. in regulations. NOTE       Many national and international regulations classify liquids as presenting a flammable hazard based on their flash point, as determined by a recognized method. Some of these regulations allow a derogation if the substance cannot “sustain combustion” at some specified temperature(s). The procedure is applicable to paints (including water-borne paints), varnishes, paint binders, solvents, petroleum or related products and adhesives, that have a flash point. It is not applicable to painted surfaces in respect of assessing their potential fire hazards. This test method is applicable, in addition to test methods for flash point, for assessing the fire hazard of a product. ","objectID":"77086_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>038:2021 Determination of sustained combustibility of liquids","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies a procedure, at temperatures up to 100 °C, to determine whether a liquid product, that would be classified as “flammable” by virtue of its flash point, sustains combustion at the temperature(s) specified e.g. in regulations. NOTE       Many national and international regulations classify liquids as presenting a flammable hazard based on their flash point, as determined by a recognized method. Some of these regulations allow a derogation if the substance cannot “sustain combustion” at some specified temperature(s). The procedure is applicable to paints (including water-borne paints), varnishes, paint binders, solvents, petroleum or related products and adhesives, that have a flash point. It is not applicable to painted surfaces in respect of assessing their potential fire hazards. This test method is applicable, in addition to test methods for flash point, for assessing the fire hazard of a product. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/68/76875","uuid":"aa304179-cdb8-4785-8959-06f100b79808","title":"ISO 9374-5:2021 Cranes — Information to be provided — Part 5: Overhead travelling cranes and portal bridge cranes","status":"Published","year":2021,"order":11,"text":"This document specifies information to be provided by: a) a purchaser in enquiring about or ordering an overhead travelling crane or portal bridge crane; b) a manufacturer in tendering for or supplying an overhead travelling crane or portal bridge crane. ","objectID":"76875_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>374-5:2021 Cranes — Information to be provided — Part 5: Overhead travelling cranes and portal bridge cranes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies information to be provided by: a) a purchaser in enquiring about or ordering an overhead travelling crane or portal bridge crane; b) a manufacturer in tendering for or supplying an overhead travelling crane or portal bridge crane. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/17/71710","uuid":"f5aeafd8-0e0a-49c2-98e4-76c9131bb4ee","title":"ISO 939:2021 Spices and condiments — Determination of moisture content","status":"Published","year":2021,"order":11,"text":"This document specifies an entrainment method for the determination of the moisture content of spices and condiments. ","objectID":"71710_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>39:2021 Spices and condiments — Determination of moisture content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies an entrainment method for the determination of the moisture content of spices and condiments. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/11/71181","uuid":"968e4151-a97c-4646-a229-371ef6db85b3","title":"ISO 9974-4:2016 Connections for general use and fluid power — Ports and stud ends with ISO 261 threads with elastomeric or metal-to-metal sealing — Part 4: Dimensions, design, test methods and requirements for external hex and internal hex port plugs","status":"Published","year":2021,"order":11,"text":"ISO 9974-4:2016 specifies dimensions and performance requirements for metric external hex and internal hex port plugs for use with ISO 9974‑1 ports. Port plugs in accordance with this document can be used at working pressures up to 63 MPa [630 bar[1]]. The permissible working pressure depends upon the plug end size, materials, design, working conditions, application, etc. Conformance to the dimensional information in this document does not guarantee rated performance. NOTE          The Introduction of this document gives recommendations for ports and stud ends to be used for new designs in hydraulic fluid power applications. [1] 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm2. ","objectID":"71181_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>974-4:2016 Connections for general use and fluid power — Ports and stud ends with <em>ISO</em> 261 threads with elastomeric or metal-to-metal sealing — Part 4: Dimensions, design, test methods and requirements for external hex and internal hex port plugs","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>974-4:2016 specifies dimensions and performance requirements for metric external hex and internal hex port plugs for use with <em>ISO</em> <em>9</em>974‑1 ports. Port plugs in accordance with this document can be used at working pressures up to 63 MPa [630 bar[1]]. The permissible working pressure depends upon the plug end size, materials, design, working conditions, application, etc. Conformance to the dimensional information in this document does not guarantee rated performance. NOTE          The Introduction of this document gives recommendations for ports and stud ends to be used for new designs in hydraulic fluid power applications. [1] 1 bar = 0,1 MPa = 105 Pa; 1 MPa = 1 N/mm2. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/10/71070","uuid":"2e401a8f-eec3-4057-8ce8-adde59391697","title":"ISO 9934-1:2016 Non-destructive testing — Magnetic particle testing — Part 1: General principles","status":"Published","year":2021,"order":11,"text":"ISO 9934-1:2016 specifies general principles for the magnetic particle testing of ferromagnetic materials. Magnetic particle testing is primarily applicable to the detection of surface-breaking discontinuities, particularly cracks. It can also detect discontinuities just below the surface but its sensitivity diminishes rapidly with depth. ISO 9934-1:2016 specifies the surface preparation of the part to be tested, magnetization techniques, requirements and application of the detection media, and the recording and interpretation of results. Acceptance criteria are not defined. Additional requirements for the magnetic particle testing of particular items are defined in product standards (see the relevant International Standards or European standards). ISO 9934-1:2016 does not apply to the residual magnetization method. ","objectID":"71070_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>934-1:2016 Non-destructive testing — Magnetic particle testing — Part 1: General principles","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>934-1:2016 specifies general principles for the magnetic particle testing of ferromagnetic materials. Magnetic particle testing is primarily applicable to the detection of surface-breaking discontinuities, particularly cracks. It can also detect discontinuities just below the surface but its sensitivity diminishes rapidly with depth. <em>ISO</em> <em>9</em>934-1:2016 specifies the surface preparation of the part to be tested, magnetization techniques, requirements and application of the detection media, and the recording and interpretation of results. Acceptance criteria are not defined. Additional requirements for the magnetic particle testing of particular items are defined in product standards (see the relevant International Standards or European standards). <em>ISO</em> <em>9</em>934-1:2016 does not apply to the residual magnetization method. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/03/70345","uuid":"84e6595d-dfaf-4e2d-ad2d-5cde97f7883e","title":"ISO 9211-1:2018 Optics and photonics — Optical coatings — Part 1: Vocabulary","status":"Published","year":2021,"order":11,"text":"This document defines terms relevant to optical coatings. These terms are grouped in four classes: Terms and definitions, definition of coatings by function, definitions of common coating imperfections and other definitions. This document identifies surface treatments of components and substrates excluding ophthalmic optics (spectacles) by the application of optical coatings and gives a standard form for their specification. It defines the general characteristics and the test and measurement methods whenever necessary, but is not intended to define the process method. ","objectID":"70345_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>211-1:2018 Optics and photonics — Optical coatings — Part 1: Vocabulary","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document defines terms relevant to optical coatings. These terms are grouped in four classes: Terms and definitions, definition of coatings by function, definitions of common coating imperfections and other definitions. This document identifies surface treatments of components and substrates excluding ophthalmic optics (spectacles) by the application of optical coatings and gives a standard form for their specification. It defines the general characteristics and the test and measurement methods whenever necessary, but is not intended to define the process method. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/03/70335","uuid":"a085730c-959a-4f95-9edb-6b7386187c16","title":"ISO 9924-2:2016 Rubber and rubber products — Determination of the composition of vulcanizates and uncured compounds by thermogravimetry — Part 2: Acrylonitrile-butadiene and halobutyl rubbers","status":"Published","year":2021,"order":11,"text":"ISO 9924-2:2016 specifies a thermogravimetric method for the determination of the total organic content, carbon black content, carbonaceous residue and ash in vulcanizates and uncured compounds containing polymers which form a carbonaceous residue on pyrolysis (see 1.2). The loss in mass at around 300 °C is an approximate guide to the volatile-matter content of the compound. The method is suitable for the analysis of rubber compounds and vulcanizates containing the hydrocarbon polymers covered by ISO 9924‑1 plus the following copolymers with polar groups which form a carbonaceous residue on pyrolysis: a)    acrylonitrile-butadiene copolymers (NBRs); b)    carboxylated acrylonitrile-butadiene copolymers (XNBRs); c)    hydrogenated acrylonitrile-butadiene copolymers (HNBRs); d)    chlorinated isobutylene-isoprene copolymers (CIIRs); e)    brominated isobutylene-isoprene copolymers (BIIRs). ","objectID":"70335_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>924-2:2016 Rubber and rubber products — Determination of the composition of vulcanizates and uncured compounds by thermogravimetry — Part 2: Acrylonitrile-butadiene and halobutyl rubbers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>924-2:2016 specifies a thermogravimetric method for the determination of the total organic content, carbon black content, carbonaceous residue and ash in vulcanizates and uncured compounds containing polymers which form a carbonaceous residue on pyrolysis (see 1.2). The loss in mass at around 300 °C is an approximate guide to the volatile-matter content of the compound. The method is suitable for the analysis of rubber compounds and vulcanizates containing the hydrocarbon polymers covered by <em>ISO</em> <em>9</em>924‑1 plus the following copolymers with polar groups which form a carbonaceous residue on pyrolysis: a)    acrylonitrile-butadiene copolymers (NBRs); b)    carboxylated acrylonitrile-butadiene copolymers (XNBRs); c)    hydrogenated acrylonitrile-butadiene copolymers (HNBRs); d)    chlorinated isobutylene-isoprene copolymers (CIIRs); e)    brominated isobutylene-isoprene copolymers (BIIRs). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/03/70333","uuid":"9b10cc9b-f96e-4c99-9e9b-1b22c8f42c89","title":"ISO 9924-1:2016 Rubber and rubber products — Determination of the composition of vulcanizates and uncured compounds by thermogravimetry — Part 1: Butadiene, ethylene-propylene copolymer and terpolymer, isobutene-isoprene, isoprene and styrene-butadiene rubbers","status":"Published","year":2021,"order":11,"text":"ISO 9924-1:2016 specifies a thermogravimetric method for the determination of the total organic content, carbon black content and ash in vulcanizates and uncured compounds. The loss in mass at 300 °C is an approximate guide to the volatile-matter content of the compound. The method is suitable for the analysis of rubber compounds and vulcanizates containing the following rubbers occurring alone or as mixtures: a)    polyisoprene of natural or synthetic origin; b)    polybutadiene; c)    styrene-butadiene copolymers; d)    isobutylene-isoprene copolymers; e)    ethylene-propylene copolymers and related terpolymers. NOTE          The field of application of the method may be extended to the analysis of compounds containing rubbers different from those given in this subclause, provided that the applicability of the method is tested beforehand using known compounds or vulcanizates having a similar composition. Other compounds are covered in ISO 9924‑2. The method is not suitable for rubbers containing polymers which form a carbonaceous residue during pyrolysis, such as many chlorine- or nitrogen-containing rubbers. The method is also not suitable for materials containing additives which cause the formation of carbonaceous residues during pyrolysis, such as cobalt and lead salts or phenolic resins. The method is not suitable for compounds containing mineral fillers, such as carbonates or hydrated aluminium oxides, which decompose in the temperature range from 25 °C to 650 °C, unless suitable corrections based on prior knowledge of filler behaviour can be made. The method is not suitable for the determination of the total polymer content of compounds or vulcanizates containing non-rubber organic ingredients that cannot be completely removed by solvent extraction carried out in accordance with ISO 1407. ","objectID":"70333_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>924-1:2016 Rubber and rubber products — Determination of the composition of vulcanizates and uncured compounds by thermogravimetry — Part 1: Butadiene, ethylene-propylene copolymer and terpolymer, isobutene-isoprene, isoprene and styrene-butadiene rubbers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>924-1:2016 specifies a thermogravimetric method for the determination of the total organic content, carbon black content and ash in vulcanizates and uncured compounds. The loss in mass at 300 °C is an approximate guide to the volatile-matter content of the compound. The method is suitable for the analysis of rubber compounds and vulcanizates containing the following rubbers occurring alone or as mixtures: a)    polyisoprene of natural or synthetic origin; b)    polybutadiene; c)    styrene-butadiene copolymers; d)    isobutylene-isoprene copolymers; e)    ethylene-propylene copolymers and related terpolymers. NOTE          The field of application of the method may be extended to the analysis of compounds containing rubbers different from those given in this subclause, provided that the applicability of the method is tested beforehand using known compounds or vulcanizates having a similar composition. Other compounds are covered in <em>ISO</em> <em>9</em>924‑2. The method is not suitable for rubbers containing polymers which form a carbonaceous residue during pyrolysis, such as many chlorine- or nitrogen-containing rubbers. The method is also not suitable for materials containing additives which cause the formation of carbonaceous residues during pyrolysis, such as cobalt and lead salts or phenolic resins. The method is not suitable for compounds containing mineral fillers, such as carbonates or hydrated aluminium oxides, which decompose in the temperature range from 25 °C to 650 °C, unless suitable corrections based on prior knowledge of filler behaviour can be made. The method is not suitable for the determination of the total polymer content of compounds or vulcanizates containing non-rubber organic ingredients that cannot be completely removed by solvent extraction carried out in accordance with <em>ISO</em> 1407. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/02/70275","uuid":"a3ebe96c-b1d5-4712-98d2-b3bc0946787f","title":"ISO 9856:2016 Conveyor belts — Determination of elastic and permanent elongation and calculation of elastic modulus","status":"Published","year":2021,"order":11,"text":"ISO 9856:2016 specifies a method for determining the elastic and permanent elongation of a conveyor belt and the calculation of the elastic modulus. It is not applicable or valid for light conveyor belts as described in ISO 21183‑1. ","objectID":"70275_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>856:2016 Conveyor belts — Determination of elastic and permanent elongation and calculation of elastic modulus","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>856:2016 specifies a method for determining the elastic and permanent elongation of a conveyor belt and the calculation of the elastic modulus. It is not applicable or valid for light conveyor belts as described in <em>ISO</em> 21183‑1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/99/69939","uuid":"ce724e8d-3719-4842-bd9a-f038e4f9478a","title":"ISO 9022-23:2016 Optics and photonics — Environmental test methods — Part 23: Low pressure combined with cold, ambient temperature and dry or damp heat","status":"Published","year":2021,"order":11,"text":"ISO 9022-23:2016 specifies the methods relating to the environmental tests of optical instruments including additional assemblies from other fields (e.g. mechanical, chemical, and electronic devices), under equivalent conditions, for their ability to resist the influence of low pressure combined with cold, including the potential condensation and freezing of moisture, ambient temperature, and dry or damp heat. It is applicable to optical instruments including additional assemblies from other fields, designed for operation and/or transport in high mountainous areas or on board aircraft or missiles. The purpose of the testing is to investigate to what extent optical, climatic, mechanical, chemical, and electrical (including electrostatic) performance characteristics of the specimen are affected by combined low pressure and low, ambient, or high temperature. Furthermore, the additional effects of moisture condensing and freezing on the instrument or components can be determined. Examples are instruments which are installed or externally mounted on aircraft or missiles or transported inside aircraft or flying objects not providing any pressure equalization. Annex A explains the intent of the different types of tests. ","objectID":"69939_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>022-23:2016 Optics and photonics — Environmental test methods — Part 23: Low pressure combined with cold, ambient temperature and dry or damp heat","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>022-23:2016 specifies the methods relating to the environmental tests of optical instruments including additional assemblies from other fields (e.g. mechanical, chemical, and electronic devices), under equivalent conditions, for their ability to resist the influence of low pressure combined with cold, including the potential condensation and freezing of moisture, ambient temperature, and dry or damp heat. It is applicable to optical instruments including additional assemblies from other fields, designed for operation and/or transport in high mountainous areas or on board aircraft or missiles. The purpose of the testing is to investigate to what extent optical, climatic, mechanical, chemical, and electrical (including electrostatic) performance characteristics of the specimen are affected by combined low pressure and low, ambient, or high temperature. Furthermore, the additional effects of moisture condensing and freezing on the instrument or components can be determined. Examples are instruments which are installed or externally mounted on aircraft or missiles or transported inside aircraft or flying objects not providing any pressure equalization. Annex A explains the intent of the different types of tests. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/99/69938","uuid":"ae65fda9-06f0-4b80-ae1c-e7c02685cd1c","title":"ISO 9022-1:2016 Optics and photonics — Environmental test methods — Part 1: Definitions, extent of testing","status":"Published","year":2021,"order":11,"text":"ISO 9022-1:2016 defines terms relating to environmental tests of optical and photonic instruments, including additional assemblies from other fields (e.g. mechanical, chemical and electronic devices), and specifies basic features of testing. ","objectID":"69938_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>022-1:2016 Optics and photonics — Environmental test methods — Part 1: Definitions, extent of testing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>022-1:2016 defines terms relating to environmental tests of optical and photonic instruments, including additional assemblies from other fields (e.g. mechanical, chemical and electronic devices), and specifies basic features of testing. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/95/69595","uuid":"75efa344-770a-4b9c-aadf-4b21a351f6a9","title":"ISO 9936:2016 Animal and vegetable fats and oils — Determination of tocopherol and tocotrienol contents by high-performance liquid chromatography","status":"Published","year":2021,"order":11,"text":"ISO 9936:2016 specifies a method for the determination of the contents of free α-, β-, γ-, and δ-tocopherols and tocotrienols (referred to jointly as tocols) in animal and vegetable fats and oils (referred to hereinafter as fats) by high-performance liquid chromatography (HPLC). For products containing tocopherol or tocotrienol esters, it is necessary to carry out a preliminary saponification. Milk and milk products (or fat coming from milk and milk products) are excluded from the Scope of this International Standard. NOTE          A suitable method involving a cold saponification procedure is described in Annex B for information only. ","objectID":"69595_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>936:2016 Animal and vegetable fats and oils — Determination of tocopherol and tocotrienol contents by high-performance liquid chromatography","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>936:2016 specifies a method for the determination of the contents of free α-, β-, γ-, and δ-tocopherols and tocotrienols (referred to jointly as tocols) in animal and vegetable fats and oils (referred to hereinafter as fats) by high-performance liquid chromatography (HPLC). For products containing tocopherol or tocotrienol esters, it is necessary to carry out a preliminary saponification. Milk and milk products (or fat coming from milk and milk products) are excluded from the Scope of this International Standard. NOTE          A suitable method involving a cold saponification procedure is described in Annex B for information only. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/91/69128","uuid":"9a5c22dd-ccc7-4a41-b39c-b89ae983b24d","title":"ISO 9177-1:2016 Mechanical pencils for technical drawings — Part 1: Classification, dimensions, performance requirements and testing","status":"Published","year":2021,"order":11,"text":"ISO 9177-1:2016 specifies classification, dimensions, performance requirements and testing for hand-held mechanical pencils used for technical drawings. ","objectID":"69128_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>177-1:2016 Mechanical pencils for technical drawings — Part 1: Classification, dimensions, performance requirements and testing","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>177-1:2016 specifies classification, dimensions, performance requirements and testing for hand-held mechanical pencils used for technical drawings. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/90/69091","uuid":"65eb7fb3-3255-458d-84b7-29f7cf266568","title":"ISO 9197:2016 Paper, board and pulps — Determination of water-soluble chlorides","status":"Published","year":2021,"order":11,"text":"ISO 9197:2016 specifies a method for the determination of water-soluble chlorides in all types of paper, board and pulp. The lower limit of the determination is 20 mg of chloride ion per kilogram of dry sample. ","objectID":"69091_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>197:2016 Paper, board and pulps — Determination of water-soluble chlorides","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>197:2016 specifies a method for the determination of water-soluble chlorides in all types of paper, board and pulp. The lower limit of the determination is 20 mg of chloride ion per kilogram of dry sample. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/85/68579","uuid":"17e658ca-9639-4d94-b27a-29fb63f5ea29","title":"ISO 9154:2016 Aerospace — Bolts, with MJ threads, made of heat-resistant nickel-based alloy, strength class 1 550 MPa — Procurement specification","status":"Published","year":2021,"order":11,"text":"ISO 9154.2016 specifies the characteristics and quality assurance requirements for MJ threads bolts made of heat-resisting nickel-base alloy, of strength class 1 550 MPa, for aerospace construction. It is applicable whenever it is referenced in a definition document. ","objectID":"68579_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>154:2016 Aerospace — Bolts, with MJ threads, made of heat-resistant nickel-based alloy, strength class 1 550 MPa — Procurement specification","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>154.2016 specifies the characteristics and quality assurance requirements for MJ threads bolts made of heat-resisting nickel-base alloy, of strength class 1 550 MPa, for aerospace construction. It is applicable whenever it is referenced in a definition document. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/85/68517","uuid":"51f72bf3-4c57-4524-8896-4db6e31e0614","title":"ISO 9717:2017 Metallic and other inorganic coatings — Phosphate conversion coating of metals","status":"Published","year":2021,"order":11,"text":"ISO 9717:2017 specifies a process for the confirmation of requirements for phosphate coatings which are usually destined for application on ferrous materials, zinc, cadmium and their alloys (see Annex B). ","objectID":"68517_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>717:2017 Metallic and other inorganic coatings — Phosphate conversion coating of metals","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>717:2017 specifies a process for the confirmation of requirements for phosphate coatings which are usually destined for application on ferrous materials, zinc, cadmium and their alloys (see Annex B). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/75/67549","uuid":"1543591d-8e3c-4ff1-9947-e4f4d3458af2","title":"ISO 9344:2016 Microscopes — Graticules for eyepieces","status":"Published","year":2021,"order":11,"text":"ISO 9344:2016 specifies dimensions and permissible material defects and processing faults for graticules with diameters of 19 mm, 21 mm and 26 mm to be used in microscope eyepieces for the purposes of measurement, assessment and comparison. ","objectID":"67549_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>344:2016 Microscopes — Graticules for eyepieces","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>344:2016 specifies dimensions and permissible material defects and processing faults for graticules with diameters of 19 mm, 21 mm and 26 mm to be used in microscope eyepieces for the purposes of measurement, assessment and comparison. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/75/67510","uuid":"aaa9b286-e37d-4c6d-bd1c-8ea8b349b543","title":"ISO 96-1:2016 Textile machinery and accessories — Rings and travellers for ring spinning and ring twisting frames — Part 1: Flange rings T and SF and their travellers","status":"Published","year":2021,"order":11,"text":"ISO 96-1:2016 specifies the principal dimensions of T- and SF-rings, and the mass and tolerance on the mass, of the appropriate travellers for flange rings employed on ring spinning and ring twisting machines. It also specifies the method of designation of the travellers. ","objectID":"67510_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>6-1:2016 Textile machinery and accessories — Rings and travellers for ring spinning and ring twisting frames — Part 1: Flange rings T and SF and their travellers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>6-1:2016 specifies the principal dimensions of T- and SF-rings, and the mass and tolerance on the mass, of the appropriate travellers for flange rings employed on ring spinning and ring twisting machines. It also specifies the method of designation of the travellers. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/72/67257","uuid":"5e88156c-0d65-4140-9ff9-b3e5497c7253","title":"ISO 9015-2:2016 Destructive tests on welds in metallic materials — Hardness testing — Part 2: Microhardness testing of welded joints","status":"Published","year":2021,"order":11,"text":"ISO 9015-2:2016 specifies microhardness testing on transverse sections of welded joints of metallic materials with high hardness gradients. It covers Vickers hardness tests in accordance with ISO 6507‑1, normally with test loads of 0,98 N to less than 49 N (HV 0,1 to less than HV 5). NOTE          Testing ensures that the highest and/or the lowest level of hardness of both parent materials (in the case of dissimilar materials both parent materials) and weld metal is determined. ISO 9015-2:2016 is not applicable to hardness testing of welds with loads of 49,03 N and above, which is covered by ISO 9015‑1. ISO 9015-2:2016 is not applicable to Vickers hardness testing of resistance spot, projection and seam welds, which is covered by ISO 14271. This part of ISO 9015 is not applicable to hardness testing of very narrow welds, e.g. those typically produced by laser and electron beam welding (see ISO 22826). ","objectID":"67257_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>015-2:2016 Destructive tests on welds in metallic materials — Hardness testing — Part 2: Microhardness testing of welded joints","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>015-2:2016 specifies microhardness testing on transverse sections of welded joints of metallic materials with high hardness gradients. It covers Vickers hardness tests in accordance with <em>ISO</em> 6507‑1, normally with test loads of 0,<em>9</em>8 N to less than 49 N (HV 0,1 to less than HV 5). NOTE          Testing ensures that the highest and/or the lowest level of hardness of both parent materials (in the case of dissimilar materials both parent materials) and weld metal is determined. <em>ISO</em> <em>9</em>015-2:2016 is not applicable to hardness testing of welds with loads of 49,03 N and above, which is covered by <em>ISO</em> <em>9</em>015‑1. <em>ISO</em> <em>9</em>015-2:2016 is not applicable to Vickers hardness testing of resistance spot, projection and seam welds, which is covered by <em>ISO</em> 14271. This part of <em>ISO</em> <em>9</em>015 is not applicable to hardness testing of very narrow welds, e.g. those typically produced by laser and electron beam welding (see <em>ISO</em> 22826). ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/67/66798","uuid":"e5941975-327a-4c49-8ea2-4b6a6a157836","title":"ISO 9221-2:2015 Furniture — Children's high chairs — Part 2: Test methods","status":"Published","year":2021,"order":11,"text":"ISO 9221-2:2015 specifies test methods for the assessment of the requirements of children's high chairs. ","objectID":"66798_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>221-2:2015 Furniture — Children's high chairs — Part 2: Test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>221-2:2015 specifies test methods for the assessment of the requirements of children's high chairs. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/67/66795","uuid":"8541ef7a-c957-40a6-84f3-760c8b3505c1","title":"ISO 9221-1:2015 Furniture — Children's high chairs — Part 1: Safety requirements","status":"Published","year":2021,"order":11,"text":"ISO 9221-1:2015 specifies safety requirements for children's high chairs intended for children from 6 months to 36 months of age. If the product can be converted into a product for which an ISO safety standard exists, it is intended that the product also fulfil the requirements of that International Standard. ","objectID":"66795_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>221-1:2015 Furniture — Children's high chairs — Part 1: Safety requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>221-1:2015 specifies safety requirements for children's high chairs intended for children from 6 months to 36 months of age. If the product can be converted into a product for which an <em>ISO</em> safety standard exists, it is intended that the product also fulfil the requirements of that International Standard. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/67/66764","uuid":"2215bcbb-02af-4762-80bf-e8b86fd95979","title":"ISO 9926-3:2016 Cranes — Training of operators — Part 3: Tower cranes","status":"Published","year":2021,"order":11,"text":"ISO 9926-3:2016 covers the specific subjects considered necessary for training tower crane operators. ","objectID":"66764_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>926-3:2016 Cranes — Training of operators — Part 3: Tower cranes","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>926-3:2016 covers the specific subjects considered necessary for training tower crane operators. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/63/66319","uuid":"d49f835e-14a5-47f1-8e54-ad45869daf48","title":"ISO 9618:2016 Aerospace — Nuts, hexagonal, slotted (castellated), reduced height, normal across flats, with MJ threads, classifications: 450 MPa (at ambient temperature)/120 degrees C, 450 MPa (at ambient temperature)/235 degrees C, 600 MPa (at ambient temperature)/425 degrees C, 900 MPa (at ambient temperature)/235 degrees C, 900 MPa (at ambient temperature)/315 degrees C, 900 MPa (at ambient temperature)/650 degrees C, 1 100 MPa (at ambient temperature)/235 degrees C, 1 100 MPa (at ambient temperature)/730 degrees C and 1 250 MPa (at ambient temperature)/600 degrees C — Dimensions","status":"Published","year":2021,"order":11,"text":"ISO 9618:2016 specifies the dimensions of hexagon slotted (castellated) nuts, reduced height, normal across flats, with MJ threads, of classifications: 450 MPa/120 °C, 450 MPa/235 °C, 600 MPa/425 °C, 900 MPa/235 °C, 900 MPa/315 °C, 900 MPa/650 °C, 1 100 MPa/235 °C, 1 100 MPa/730 °C, and 1 250 MPa/600 °C. These nuts are intended to be used with split pins in conformity with ISO 1234. ISO 9618:2016 is applicable for the compilation of aerospace product standards. ","objectID":"66319_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>618:2016 Aerospace — Nuts, hexagonal, slotted (castellated), reduced height, normal across flats, with MJ threads, classifications: 450 MPa (at ambient temperature)/120 degrees C, 450 MPa (at ambient temperature)/235 degrees C, 600 MPa (at ambient temperature)/425 degrees C, <em>9</em>00 MPa (at ambient temperature)/235 degrees C, <em>9</em>00 MPa (at ambient temperature)/315 degrees C, <em>9</em>00 MPa (at ambient temperature)/650 degrees C, 1 100 MPa (at ambient temperature)/235 degrees C, 1 100 MPa (at ambient temperature)/730 degrees C and 1 250 MPa (at ambient temperature)/600 degrees C — Dimensions","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>618:2016 specifies the dimensions of hexagon slotted (castellated) nuts, reduced height, normal across flats, with MJ threads, of classifications: 450 MPa/120 °C, 450 MPa/235 °C, 600 MPa/425 °C, <em>9</em>00 MPa/235 °C, <em>9</em>00 MPa/315 °C, <em>9</em>00 MPa/650 °C, 1 100 MPa/235 °C, 1 100 MPa/730 °C, and 1 250 MPa/600 °C. These nuts are intended to be used with split pins in conformity with <em>ISO</em> 1234. <em>ISO</em> <em>9</em>618:2016 is applicable for the compilation of aerospace product standards. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/63/66318","uuid":"c3080133-4acb-4db6-86ff-2aaafba5a3f7","title":"ISO 9609:2016 Aerospace — Nuts, hexagonal, plain, reduced height, normal across flats, with MJ threads, classifications: 450 MPa (at ambient temperature) /120 degrees C, 450 MPa (at ambient temperature) /235 degrees C, 600 MPa (at ambient temperature) /425 degrees C, 900 MPa (at ambient temperature) /235 degrees C, 900 MPa (at ambient temperature) /315 degrees C, 900 MPa (at ambient temperature) /650 degrees C, 1 100 MPa (at ambient temperature) /235 degrees C, 1 100 MPa (at ambient temperature) /730 degrees C and 1 250 MPa (at ambient temperature)/600 degrees C — Dimensions","status":"Published","year":2021,"order":11,"text":"ISO 9609:2016 specifies the dimensions of plain, hexagonal nuts, reduced height, normal across flats, with MJ threads, of classifications: 450 MPa/120 °C, 450 MPa/235 °C, 600 MPa/425 °C, 900 MPa/235 °C, 900 MPa/315 °C, 900 MPa/650 °C, 1 100 MPa/235 °C, 1 100 MPa/730 °C, and 1 250 MPa/600 °C. NOTE 1       450 MPa, 600 MPa, 900 MPa, 1 100 MPa and 1 250 MPa corresponds to the minimum tensile stress which the nut is able to withstand at ambient temperature without breaking or cracking when tested with a bolt of a higher strength class. NOTE 2       120 °C, 235 °C, 425 °C, 315 °C, 650 °C, 730 °C and 600 °C corresponds to the maximum temperature that the nut is able to withstand without permanent alteration to its original characteristics, after ambient temperature has been restored. The maximum temperature is conditioned by the surface treatment. Nuts provided with holes are intended to be used with lockwire in conformity with ISO 245. ISO 9609:2016 is only applicable for the compilation of aerospace product standards. ","objectID":"66318_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>609:2016 Aerospace — Nuts, hexagonal, plain, reduced height, normal across flats, with MJ threads, classifications: 450 MPa (at ambient temperature) /120 degrees C, 450 MPa (at ambient temperature) /235 degrees C, 600 MPa (at ambient temperature) /425 degrees C, <em>9</em>00 MPa (at ambient temperature) /235 degrees C, <em>9</em>00 MPa (at ambient temperature) /315 degrees C, <em>9</em>00 MPa (at ambient temperature) /650 degrees C, 1 100 MPa (at ambient temperature) /235 degrees C, 1 100 MPa (at ambient temperature) /730 degrees C and 1 250 MPa (at ambient temperature)/600 degrees C — Dimensions","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>609:2016 specifies the dimensions of plain, hexagonal nuts, reduced height, normal across flats, with MJ threads, of classifications: 450 MPa/120 °C, 450 MPa/235 °C, 600 MPa/425 °C, <em>9</em>00 MPa/235 °C, <em>9</em>00 MPa/315 °C, <em>9</em>00 MPa/650 °C, 1 100 MPa/235 °C, 1 100 MPa/730 °C, and 1 250 MPa/600 °C. NOTE 1       450 MPa, 600 MPa, <em>9</em>00 MPa, 1 100 MPa and 1 250 MPa corresponds to the minimum tensile stress which the nut is able to withstand at ambient temperature without breaking or cracking when tested with a bolt of a higher strength class. NOTE 2       120 °C, 235 °C, 425 °C, 315 °C, 650 °C, 730 °C and 600 °C corresponds to the maximum temperature that the nut is able to withstand without permanent alteration to its original characteristics, after ambient temperature has been restored. The maximum temperature is conditioned by the surface treatment. Nuts provided with holes are intended to be used with lockwire in conformity with <em>ISO</em> 245. <em>ISO</em> <em>9</em>609:2016 is only applicable for the compilation of aerospace product standards. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/51/65160","uuid":"a089295e-1aa2-4088-9f1e-a5455e421923","title":"ISO 9173-1:2016 Dentistry — Extraction forceps — Part 1: General requirements","status":"Published","year":2021,"order":11,"text":"ISO 9173-1:2016 specifies the general performance requirements for extraction forceps used in dentistry. ","objectID":"65160_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>173-1:2016 Dentistry — Extraction forceps — Part 1: General requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>173-1:2016 specifies the general performance requirements for extraction forceps used in dentistry. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/47/64742","uuid":"0d4c50e3-7805-4224-aaee-1ddfd92d904b","title":"ISO 9994:2018 Lighters — Safety specifications","status":"Published","year":2021,"order":11,"text":"This document specifies requirements for lighters to ensure a reasonable degree of safety for normal use or reasonably foreseeable misuse of such lighters by users. This document applies to all flame-producing products commonly known as cigarette lighters, cigar lighters and pipe lighters. It does not apply to matches and flame-producing products intended solely for igniting materials other than cigarettes, cigars, and pipes. ","objectID":"64742_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>994:2018 Lighters — Safety specifications","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"This document specifies requirements for lighters to ensure a reasonable degree of safety for normal use or reasonably foreseeable misuse of such lighters by users. This document applies to all flame-producing products commonly known as cigarette lighters, cigar lighters and pipe lighters. It does not apply to matches and flame-producing products intended solely for igniting materials other than cigarettes, cigars, and pipes. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/25/62519","uuid":"71f4f419-da5c-4b60-bf1d-cfa9f61e57ad","title":"ISO 9692-3:2016 Welding and allied processes — Types of joint preparation — Part 3: Metal inert gas welding and tungsten inert gas welding of aluminium and its alloys","status":"Published","year":2021,"order":11,"text":"ISO 9692-3:2016 specifies recommended types of joint preparation for metal inert gas welding, MIG (131), and tungsten inert gas welding, TIG (141), and autogenous TIG welding (142) on aluminium and its alloys. It applies to fully penetrated welds. ","objectID":"62519_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>692-3:2016 Welding and allied processes — Types of joint preparation — Part 3: Metal inert gas welding and tungsten inert gas welding of aluminium and its alloys","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>692-3:2016 specifies recommended types of joint preparation for metal inert gas welding, MIG (131), and tungsten inert gas welding, TIG (141), and autogenous TIG welding (142) on aluminium and its alloys. It applies to fully penetrated welds. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/24/62411","uuid":"9d7a8191-872f-4113-a2c5-654a40f98d22","title":"ISO 9044:2016 Industrial woven wire cloth — Technical requirements and tests","status":"Published","year":2021,"order":11,"text":"ISO 9044:2016 defines terms regarding industrial woven wire cloth for screening purposes and specifies maximum permissible error, requirements, and test methods. It applies to industrial woven wire cloth with square apertures, made of steel, stainless steel, or non-ferrous metals (see ISO 4783‑2). It does not apply to woven wire cloth coated after weaving nor does it apply to pre-crimped and welded wire screens which are covered in ISO 4783‑3 and ISO 14315. It is of limited application to woven wire cloth used for purposes other than screening which may necessitate other requirements. The alternative requirements may be agreed between the purchaser and the supplier at the time of placing the order. ","objectID":"62411_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>044:2016 Industrial woven wire cloth — Technical requirements and tests","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>044:2016 defines terms regarding industrial woven wire cloth for screening purposes and specifies maximum permissible error, requirements, and test methods. It applies to industrial woven wire cloth with square apertures, made of steel, stainless steel, or non-ferrous metals (see <em>ISO</em> 4783‑2). It does not apply to woven wire cloth coated after weaving nor does it apply to pre-crimped and welded wire screens which are covered in <em>ISO</em> 4783‑3 and <em>ISO</em> 14315. It is of limited application to woven wire cloth used for purposes other than screening which may necessitate other requirements. The alternative requirements may be agreed between the purchaser and the supplier at the time of placing the order. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/23/62370","uuid":"62bb966b-e87d-48b9-8432-ed8c867a0c6a","title":"ISO 9969:2016 Thermoplastics pipes — Determination of ring stiffness","status":"Published","year":2021,"order":11,"text":"ISO 9969:2016 specifies a test method for determining the ring stiffness of thermoplastics pipes having a circular cross section. ","objectID":"62370_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>969:2016 Thermoplastics pipes — Determination of ring stiffness","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>969:2016 specifies a test method for determining the ring stiffness of thermoplastics pipes having a circular cross section. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/23/62369","uuid":"033cdc48-65ee-4c31-a061-24143fab0df8","title":"ISO 9967:2016 Thermoplastics pipes — Determination of creep ratio","status":"Published","year":2021,"order":11,"text":"ISO 9967:2016 specifies a method for determining the creep ratio of thermoplastics pipes having a circular cross-section. ","objectID":"62369_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>967:2016 Thermoplastics pipes — Determination of creep ratio","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>967:2016 specifies a method for determining the creep ratio of thermoplastics pipes having a circular cross-section. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/20/62085","uuid":"67e64672-aa6a-4887-9acd-e9e233acbb73","title":"ISO 9001:2015 Quality management systems — Requirements","status":"Published","year":2021,"order":11,"text":"ISO 9001:2015 specifies requirements for a quality management system when an organization: a)    needs to demonstrate its ability to consistently provide products and services that meet customer and applicable statutory and regulatory requirements, and b)    aims to enhance customer satisfaction through the effective application of the system, including processes for improvement of the system and the assurance of conformity to customer and applicable statutory and regulatory requirements. All the requirements of ISO 9001:2015 are generic and are intended to be applicable to any organization, regardless of its type or size, or the products and services it provides. ","objectID":"62085_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>001:2015 Quality management systems — Requirements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>001:2015 specifies requirements for a quality management system when an organization: a)    needs to demonstrate its ability to consistently provide products and services that meet customer and applicable statutory and regulatory requirements, and b)    aims to enhance customer satisfaction through the effective application of the system, including processes for improvement of the system and the assurance of conformity to customer and applicable statutory and regulatory requirements. All the requirements of <em>ISO</em> <em>9</em>001:2015 are generic and are intended to be applicable to any organization, regardless of its type or size, or the products and services it provides. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/18/61814","uuid":"d211e2cc-89cc-475f-a0cc-92c129228656","title":"ISO 9649:2016 Metallic materials — Wire — Reverse torsion test","status":"Published","year":2021,"order":11,"text":"ISO 9649:2016 specifies a method for determining the ability of metallic wire of diameter dimension from 0,3 mm to 10,0 mm inclusive to undergo plastic deformation during reverse torsion. This test is used to detect surface defects, as well as to assess ductility. ","objectID":"61814_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>649:2016 Metallic materials — Wire — Reverse torsion test","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>649:2016 specifies a method for determining the ability of metallic wire of diameter dimension from 0,3 mm to 10,0 mm inclusive to undergo plastic deformation during reverse torsion. This test is used to detect surface defects, as well as to assess ductility. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/16/61639","uuid":"8f0a86a3-09a3-455b-9edb-2280eac3323b","title":"ISO 9563:2015 Belt drives — Electrical conductivity of antistatic endless synchronous belts — Characteristics and test method","status":"Published","year":2021,"order":11,"text":"ISO 9563:2015 specifies the maximum and minimum electrical resistance of antistatic endless and open ended synchronous belts. This International Standard provides guidelines to allow testing of synchronous belts to prove their static conductive (dissipative) properties as well as a corresponding production control test method. The application of this International Standard is limited to new belts intended to be used in an explosive atmosphere or in situations where there is a fire risk. The test is intended to ensure that the belt is sufficiently conductive to dissipate charges of electricity which may form on it in service. In the case of a production control test, the decision is left to national standards or agreement between interested parties as to whether the test shall be carried out on each belt in a batch or on only a percentage of belts in a batch. For each proof test, the belt manufacturer shall determine which type of electrode and conductive coating material shall be used. ","objectID":"61639_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>563:2015 Belt drives — Electrical conductivity of antistatic endless synchronous belts — Characteristics and test method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>563:2015 specifies the maximum and minimum electrical resistance of antistatic endless and open ended synchronous belts. This International Standard provides guidelines to allow testing of synchronous belts to prove their static conductive (dissipative) properties as well as a corresponding production control test method. The application of this International Standard is limited to new belts intended to be used in an explosive atmosphere or in situations where there is a fire risk. The test is intended to ensure that the belt is sufficiently conductive to dissipate charges of electricity which may form on it in service. In the case of a production control test, the decision is left to national standards or agreement between interested parties as to whether the test shall be carried out on each belt in a batch or on only a percentage of belts in a batch. For each proof test, the belt manufacturer shall determine which type of electrode and conductive coating material shall be used. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/14/61434","uuid":"12e8bc08-23da-4ef3-81aa-d60be00f6026","title":"ISO 9735-10:2014 Electronic data interchange for administration, commerce and transport (EDIFACT) — Application level syntax rules (Syntax version number: 4, Syntax release number: 2) — Part 10: Syntax service directories","status":"Published","year":2021,"order":11,"text":"ISO 9735-10:2014 specifies the syntax service directories of all parts of ISO 9735. ","objectID":"61434_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>735-10:2014 Electronic data interchange for administration, commerce and transport (EDIFACT) — Application level syntax rules (Syntax version number: 4, Syntax release number: 2) — Part 10: Syntax service directories","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>735-10:2014 specifies the syntax service directories of all parts of <em>ISO</em> <em>9</em>735. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/12/61246","uuid":"ab7bcf87-8deb-4321-9c60-b21a816abdb7","title":"ISO 9564-4:2016 Financial services — Personal Identification Number (PIN) management and security — Part 4: Requirements for PIN handling in eCommerce for Payment Transactions","status":"Published","year":2021,"order":11,"text":"ISO 9564-4:2016 provides requirements for the use of personal identification numbers (PIN) in eCommerce. The PINs in scope are the same cardholder PINs used as a means of cardholder verification in card-based financial transactions; notably, automated teller machine (ATM) systems, point-of-sale (POS) terminals, automated fuel dispensers, and vending machines. It is applicable to financial card-originated transactions requiring verification of the PIN and to those organizations responsible for implementing techniques for the management of the PIN in eCommerce. The provisions of this part of ISO 9564 are not intended to cover -      passwords, passcodes, pass phrases and other shared secrets used for customer authentication in online banking, telephone banking, digital wallets, mobile payment, etc., -      management of cardholder PINs for use as a means of cardholder verification in retail banking systems in, notably, automated teller machine (ATM) systems, point-of-sale (POS) terminals, automated fuel dispensers, vending machines, banking kiosks and PIN selection/change systems, which are covered in ISO 9564‑1, -      card proxies such as mobile phones or key fobs, -      approved algorithms for PIN encipherment, which are covered in ISO 9564‑2, -      the protection of the PIN against loss or intentional misuse by the customer or authorized employees of the issuer, -      privacy of non-PIN transaction data, -      protection of transaction messages against alteration or substitution, e.g. an online authorization response, -      protection against replay of the transaction, -      functionality of devices used for PIN entry which is related to issuer functions other than PIN entry, -      specific key management techniques, and -      access to, and storage of, card data other than the PIN by applications such as wallets. ","objectID":"61246_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>564-4:2016 Financial services — Personal Identification Number (PIN) management and security — Part 4: Requirements for PIN handling in eCommerce for Payment Transactions","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>564-4:2016 provides requirements for the use of personal identification numbers (PIN) in eCommerce. The PINs in scope are the same cardholder PINs used as a means of cardholder verification in card-based financial transactions; notably, automated teller machine (ATM) systems, point-of-sale (POS) terminals, automated fuel dispensers, and vending machines. It is applicable to financial card-originated transactions requiring verification of the PIN and to those organizations responsible for implementing techniques for the management of the PIN in eCommerce. The provisions of this part of <em>ISO</em> <em>9</em>564 are not intended to cover -      passwords, passcodes, pass phrases and other shared secrets used for customer authentication in online banking, telephone banking, digital wallets, mobile payment, etc., -      management of cardholder PINs for use as a means of cardholder verification in retail banking systems in, notably, automated teller machine (ATM) systems, point-of-sale (POS) terminals, automated fuel dispensers, vending machines, banking kiosks and PIN selection/change systems, which are covered in <em>ISO</em> <em>9</em>564‑1, -      card proxies such as mobile phones or key fobs, -      approved algorithms for PIN encipherment, which are covered in <em>ISO</em> <em>9</em>564‑2, -      the protection of the PIN against loss or intentional misuse by the customer or authorized employees of the issuer, -      privacy of non-PIN transaction data, -      protection of transaction messages against alteration or substitution, e.g. an online authorization response, -      protection against replay of the transaction, -      functionality of devices used for PIN entry which is related to issuer functions other than PIN entry, -      specific key management techniques, and -      access to, and storage of, card data other than the PIN by applications such as wallets. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/07/60719","uuid":"4e3056b8-bfdf-4219-b825-45cb94967587","title":"ISO 9182-2:2013 Tools for pressing — Guide pillars — Part 2: Type A, straight pillars","status":"Published","year":2021,"order":11,"text":"ISO 9182-2;2013 specifies the dimensions and tolerances, in millimetres, of guide pillars, type A, intended for use in press tools. These guide pillars can be straight, type A1, or straight with end-locking and locking ring, type A2. It gives guidance on the materials and specifies the hardness and the designation of guide pillars which meet its requirements. ","objectID":"60719_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>182-2:2013 Tools for pressing — Guide pillars — Part 2: Type A, straight pillars","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>182-2;2013 specifies the dimensions and tolerances, in millimetres, of guide pillars, type A, intended for use in press tools. These guide pillars can be straight, type A1, or straight with end-locking and locking ring, type A2. It gives guidance on the materials and specifies the hardness and the designation of guide pillars which meet its requirements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/07/60718","uuid":"8fc39a98-d942-4c19-a60b-43e8b00a5b0f","title":"ISO 9182-1:2013 Tools for pressing — Guide pillars — Part 1: Types","status":"Published","year":2021,"order":11,"text":"ISO 9182-1:2013 illustrates four main types of guide pillars and their methods of mounting. ","objectID":"60718_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>182-1:2013 Tools for pressing — Guide pillars — Part 1: Types","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>182-1:2013 illustrates four main types of guide pillars and their methods of mounting. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/04/60480","uuid":"519de844-51a7-4b6c-9d06-9906fbe2ae46","title":"ISO 9626:2016 Stainless steel needle tubing for the manufacture of medical devices — Requirements and test methods","status":"Published","year":2021,"order":11,"text":"ISO 9626:2016 applies to rigid stainless steel needle tubing suitable for use in the manufacture of hypodermic needles and other medical devices primarily for human use. It provides requirements and test methods for the tubes manufactured for needles as component used in medical devices. Additional performance testing on the tube aspect may be required when the component is incorporated in the ready-to-use device. It specifies the dimensions and mechanical properties of steel tubing of designated metric sizes 3,4 mm (10 Gauge) to 0,18 mm (34 Gauge). It does not apply to flexible stainless steel tubing because the mechanical properties differ from those specified for rigid tubing in ISO 9626:2016. However, manufacturers and purchasers of flexible tubing are encouraged to adopt the dimensional specifications given in ISO 9626:2016. ","objectID":"60480_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>626:2016 Stainless steel needle tubing for the manufacture of medical devices — Requirements and test methods","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>626:2016 applies to rigid stainless steel needle tubing suitable for use in the manufacture of hypodermic needles and other medical devices primarily for human use. It provides requirements and test methods for the tubes manufactured for needles as component used in medical devices. Additional performance testing on the tube aspect may be required when the component is incorporated in the ready-to-use device. It specifies the dimensions and mechanical properties of steel tubing of designated metric sizes 3,4 mm (10 Gauge) to 0,18 mm (34 Gauge). It does not apply to flexible stainless steel tubing because the mechanical properties differ from those specified for rigid tubing in <em>ISO</em> <em>9</em>626:2016. However, manufacturers and purchasers of flexible tubing are encouraged to adopt the dimensional specifications given in <em>ISO</em> <em>9</em>626:2016. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/04/60476","uuid":"f0cb6b0b-c3f0-4273-b3bf-ca16f682d607","title":"ISO 9241-161:2016 Ergonomics of human-system interaction — Part 161: Guidance on visual user-interface elements","status":"Published","year":2021,"order":11,"text":"ISO 9241-161:2016 describes visual user-interface elements presented by software and provides requirements and recommendations on when and how to use them. This part of ISO 9241 is concerned with software components of interactive systems to make human-system interaction usable as far as the basic interaction aspects are concerned. ISO 9241-161:2016 provides a comprehensive list of generic visual user-interface elements, regardless of a specific input method, visualization, and platform or implementation technology. The guidance given in this part of ISO 9241 is intended to be used in conjunction with ISO 9241 guidance on dialogue techniques. It recognizes that additional elements can evolve. It also addresses derivates, compositions (assemblies) and states of user-interface elements. It gives requirements and recommendations on selection, usage and dependencies of user-interface elements and their application. It is applicable regardless of a fixed, portable or mobile interactive system. It does not provide detailed coverage of the methods and techniques required for design of user-interface elements. This part of ISO 9241 does not address implementation (e.g. graphical design of elements) and interaction details for specific input methods or technologies. It does not cover decorative user-interface elements that are intended to address solely aesthetic (hedonic) qualities in the user interface, e.g. background images. The information in this part of ISO 9241 is intended for use by those responsible for the selection and implementation of visual user-interface elements in interactive systems and for evaluating user interfaces. It is intended for use by those planning and managing platform specific aspects of user interface screen design. It also provides guidance for human factors/ergonomics and usability professionals involved in human-centred design. It addresses technical issues only to the extent necessary to allow users of this part of ISO 9241 to understand the relevance and importance of a consistent interface element usage and selection in the design process as a whole. Annex A provides a guide to selection of different visual user interface elements depending of their appropriate application. ","objectID":"60476_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>241-161:2016 Ergonomics of human-system interaction — Part 161: Guidance on visual user-interface elements","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>241-161:2016 describes visual user-interface elements presented by software and provides requirements and recommendations on when and how to use them. This part of <em>ISO</em> <em>9</em>241 is concerned with software components of interactive systems to make human-system interaction usable as far as the basic interaction aspects are concerned. <em>ISO</em> <em>9</em>241-161:2016 provides a comprehensive list of generic visual user-interface elements, regardless of a specific input method, visualization, and platform or implementation technology. The guidance given in this part of <em>ISO</em> <em>9</em>241 is intended to be used in conjunction with <em>ISO</em> <em>9</em>241 guidance on dialogue techniques. It recognizes that additional elements can evolve. It also addresses derivates, compositions (assemblies) and states of user-interface elements. It gives requirements and recommendations on selection, usage and dependencies of user-interface elements and their application. It is applicable regardless of a fixed, portable or mobile interactive system. It does not provide detailed coverage of the methods and techniques required for design of user-interface elements. This part of <em>ISO</em> <em>9</em>241 does not address implementation (e.g. graphical design of elements) and interaction details for specific input methods or technologies. It does not cover decorative user-interface elements that are intended to address solely aesthetic (hedonic) qualities in the user interface, e.g. background images. The information in this part of <em>ISO</em> <em>9</em>241 is intended for use by those responsible for the selection and implementation of visual user-interface elements in interactive systems and for evaluating user interfaces. It is intended for use by those planning and managing platform specific aspects of user interface screen design. It also provides guidance for human factors/ergonomics and usability professionals involved in human-centred design. It addresses technical issues only to the extent necessary to allow users of this part of <em>ISO</em> <em>9</em>241 to understand the relevance and importance of a consistent interface element usage and selection in the design process as a whole. Annex A provides a guide to selection of different visual user interface elements depending of their appropriate application. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/03/60317","uuid":"1f5cba2b-f74d-4297-bb22-25d39d7966a1","title":"ISO 9241-392:2015 Ergonomics of human-system interaction — Part 392: Ergonomic recommendations for the reduction of visual fatigue from stereoscopic images","status":"Published","year":2021,"order":11,"text":"ISO 9241-392:2015 establishes recommendations for reducing the potential visual discomfort and visual fatigue experienced during viewing of stereoscopic images under defined viewing conditions. Visual fatigue and discomfort might be produced by the stereoscopic optical stimulus of disparate images that were presented binocularly. ISO 9241-392:2015 is also applicable to the final products of stereoscopic presentations which depend on stereoscopic image content and stereoscopic displays when viewed under appropriate defined conditions. Therefore, the recommendations are intended for people responsible for the design, development, and supply of stereoscopic image content as well as stereoscopic displays. NOTE 1       See Annex B for appropriate viewing conditions. The recommendations in this part of ISO 9241 are applicable to stereoscopic displays such as those with glasses and two-view autostereoscopic displays, stereoscopic head-mounted displays, and stereoscopic projectors. Moreover, they are applicable to stereoscopic image content intended to be presented on the above-mentioned stereoscopic displays and stereoscopic presentations that are realized by the combinations of these images and displays. NOTE 2       Annex C presents numerical criteria as an informative reference. NOTE 3       Other guidance might need to be established by referring to this part of ISO 9241 when requirements and recommendations specific to each type of stereoscopic image content or stereoscopic display become necessary. NOTE 4       ITU generally sets the standards for broadcasting. NOTE 5       ISO 9241‑303:2011, Annex E provides guidelines for virtual displays which are intended for stereoscopic head-mounted displays. ","objectID":"60317_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>241-392:2015 Ergonomics of human-system interaction — Part 392: Ergonomic recommendations for the reduction of visual fatigue from stereoscopic images","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>241-392:2015 establishes recommendations for reducing the potential visual discomfort and visual fatigue experienced during viewing of stereoscopic images under defined viewing conditions. Visual fatigue and discomfort might be produced by the stereoscopic optical stimulus of disparate images that were presented binocularly. <em>ISO</em> <em>9</em>241-392:2015 is also applicable to the final products of stereoscopic presentations which depend on stereoscopic image content and stereoscopic displays when viewed under appropriate defined conditions. Therefore, the recommendations are intended for people responsible for the design, development, and supply of stereoscopic image content as well as stereoscopic displays. NOTE 1       See Annex B for appropriate viewing conditions. The recommendations in this part of <em>ISO</em> <em>9</em>241 are applicable to stereoscopic displays such as those with glasses and two-view autostereoscopic displays, stereoscopic head-mounted displays, and stereoscopic projectors. Moreover, they are applicable to stereoscopic image content intended to be presented on the above-mentioned stereoscopic displays and stereoscopic presentations that are realized by the combinations of these images and displays. NOTE 2       Annex C presents numerical criteria as an informative reference. NOTE 3       Other guidance might need to be established by referring to this part of <em>ISO</em> <em>9</em>241 when requirements and recommendations specific to each type of stereoscopic image content or stereoscopic display become necessary. NOTE 4       ITU generally sets the standards for broadcasting. NOTE 5       <em>ISO</em> <em>9</em>241‑303:2011, Annex E provides guidelines for virtual displays which are intended for stereoscopic head-mounted displays. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/98/59895","uuid":"c5e4697e-f351-4964-bcb2-d61a86eab76e","title":"ISO 9705-1:2016 Reaction to fire tests — Room corner test for wall and ceiling lining products — Part 1: Test method for a small room configuration","status":"Published","year":2021,"order":11,"text":"ISO 9705-1:2016 specifies the test method to evaluate the reaction of wall and ceiling products to fire when installed at the surface of a small room and exposed directly to a specified ignition source. The test represents a fire scenario, which starts under well-ventilated conditions in a corner of a specified room with a single open doorway. Tests performed in accordance with the method specified in this part of ISO 9705 provide data for the early stages of a fire from ignition up to flashover. The method does not evaluate the fire resistance of products. The method is not intended to evaluate floor coverings. This method is not suitable for sandwich panel building systems, pipe insulation and façades for which specific ISO standards (i.e. ISO 13784, ISO 20632 and ISO 13785, respectively) are available. ","objectID":"59895_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>705-1:2016 Reaction to fire tests — Room corner test for wall and ceiling lining products — Part 1: Test method for a small room configuration","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>705-1:2016 specifies the test method to evaluate the reaction of wall and ceiling products to fire when installed at the surface of a small room and exposed directly to a specified ignition source. The test represents a fire scenario, which starts under well-ventilated conditions in a corner of a specified room with a single open doorway. Tests performed in accordance with the method specified in this part of <em>ISO</em> <em>9</em>705 provide data for the early stages of a fire from ignition up to flashover. The method does not evaluate the fire resistance of products. The method is not intended to evaluate floor coverings. This method is not suitable for sandwich panel building systems, pipe insulation and façades for which specific <em>ISO</em> standards (i.e. <em>ISO</em> 13784, <em>ISO</em> 20632 and <em>ISO</em> 13785, respectively) are available. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/96/59641","uuid":"b017b1bb-70bc-4750-af7d-ca0845369aaa","title":"ISO 9863-1:2016 Geosynthetics — Determination of thickness at specified pressures — Part 1: Single layers","status":"Published","year":2021,"order":11,"text":"ISO 9863-1:2016 specifies a method for the determination of the thickness of geosynthetics at specified pressures and specified load plate areas or under specified point loads. It defines the pressures or the load at which the thickness is determined. The test results are intended for identification purposes and for use in technical data sheets and/or as part of other test methods, e.g. tests of hydraulic properties. The method is applicable to all geosynthetics. ","objectID":"59641_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>863-1:2016 Geosynthetics — Determination of thickness at specified pressures — Part 1: Single layers","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>863-1:2016 specifies a method for the determination of the thickness of geosynthetics at specified pressures and specified load plate areas or under specified point loads. It defines the pressures or the load at which the thickness is determined. The test results are intended for identification purposes and for use in technical data sheets and/or as part of other test methods, e.g. tests of hydraulic properties. The method is applicable to all geosynthetics. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/78/57831","uuid":"6baa4cf5-8b72-486e-9e4d-4a092d43ce97","title":"ISO 9454-1:2016 Soft soldering fluxes — Classification and requirements — Part 1: Classification, labelling and packaging","status":"Published","year":2021,"order":11,"text":"ISO 9454-1:2016 specifies a coding system for the classification of fluxes intended for use with soft solders, according to their active fluxing ingredients, together with requirements for labelling and packaging. ","objectID":"57831_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>454-1:2016 Soft soldering fluxes — Classification and requirements — Part 1: Classification, labelling and packaging","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>454-1:2016 specifies a coding system for the classification of fluxes intended for use with soft solders, according to their active fluxing ingredients, together with requirements for labelling and packaging. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/63/56350","uuid":"6348c036-104f-4c0e-bb9a-e6c4ed7f0c76","title":"ISO 9241-391:2016 Ergonomics of human-system interaction — Part 391: Requirements, analysis and compliance test methods for the reduction of photosensitive seizures","status":"Published","year":2021,"order":11,"text":"ISO 9241-391:2016 provides requirements and recommendations for reducing photosensitive seizures (PSS), while viewing images on electronic displays. The requirements and recommendations in this part of ISO 9241 are designed to be applied to image contents. By image contents, reference is made to the images independent of the device or environment in which they are displayed. The requirements and recommendations in this part of ISO 9241 are for the protection of the vulnerable individuals in the viewing population who are photosensitive and who are therefore liable to seizures triggered by flashing lights and regular patterns, including certain repetitive images. NOTE 1       ITU considers the image safety issues in relation to broadcasting. Some of these are described in ITU-R BT.1702.[2] NOTE 2       There are some related recommendations in ISO/IEC 40500:2012, W3C Web Content Accessibility Guidelines (WCAG) 2.0, for web contents accessibility. NOTE 3       Photosensitive seizures and photosensitive epilepsy, that is, chronic conditions characterized by those repeated seizures are medical conditions. Clinical aspects of photosensitivity appear in Annex C. Visually induced seizures are equivalent to PSS. ","objectID":"56350_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>241-391:2016 Ergonomics of human-system interaction — Part 391: Requirements, analysis and compliance test methods for the reduction of photosensitive seizures","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>241-391:2016 provides requirements and recommendations for reducing photosensitive seizures (PSS), while viewing images on electronic displays. The requirements and recommendations in this part of <em>ISO</em> <em>9</em>241 are designed to be applied to image contents. By image contents, reference is made to the images independent of the device or environment in which they are displayed. The requirements and recommendations in this part of <em>ISO</em> <em>9</em>241 are for the protection of the vulnerable individuals in the viewing population who are photosensitive and who are therefore liable to seizures triggered by flashing lights and regular patterns, including certain repetitive images. NOTE 1       ITU considers the image safety issues in relation to broadcasting. Some of these are described in ITU-R BT.1702.[2] NOTE 2       There are some related recommendations in <em>ISO</em>/IEC 40500:2012, W3C Web Content Accessibility Guidelines (WCAG) 2.0, for web contents accessibility. NOTE 3       Photosensitive seizures and photosensitive epilepsy, that is, chronic conditions characterized by those repeated seizures are medical conditions. Clinical aspects of photosensitivity appear in Annex C. Visually induced seizures are equivalent to PSS. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/59/55921","uuid":"61fbded3-dda3-4650-88d8-1b4e07cd4808","title":"ISO 9187-2:2010 Injection equipment for medical use — Part 2: One-point-cut (OPC) ampoules","status":"Published","year":2021,"order":11,"text":"ISO 9187-2:2010 specifies materials, dimensions and requirements for forms of one-point-cut (OPC) ampoules (forms B, C and D) for injectables. Ampoules complying with ISO 9187-2:2010 are intended for single use only. ","objectID":"55921_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>187-2:2010 Injection equipment for medical use — Part 2: One-point-cut (OPC) ampoules","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>187-2:2010 specifies materials, dimensions and requirements for forms of one-point-cut (OPC) ampoules (forms B, C and D) for injectables. Ampoules complying with <em>ISO</em> <em>9</em>187-2:2010 are intended for single use only. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/59/55920","uuid":"47090f51-e7b5-499f-92bf-63745cc81066","title":"ISO 9187-1:2010 Injection equipment for medical use — Part 1: Ampoules for injectables","status":"Published","year":2021,"order":11,"text":"ISO 9187-1:2010 specifies materials, dimensions, capacities, performance and packaging requirements for three forms of glass ampoule (forms B, C and D) for injectable pharmaceutical products. ISO 9187-1:2010 is applicable to ampoules with and without a colour break-ring; the provision of ampoules with a colour break-ring, and the choice of colour of the break-ring, is subject to agreement between the manufacturer and user. Ampoules complying with ISO 9187-1:2010 are intended for single use only. ","objectID":"55920_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>187-1:2010 Injection equipment for medical use — Part 1: Ampoules for injectables","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>187-1:2010 specifies materials, dimensions, capacities, performance and packaging requirements for three forms of glass ampoule (forms B, C and D) for injectable pharmaceutical products. <em>ISO</em> <em>9</em>187-1:2010 is applicable to ampoules with and without a colour break-ring; the provision of ampoules with a colour break-ring, and the choice of colour of the break-ring, is subject to agreement between the manufacturer and user. Ampoules complying with <em>ISO</em> <em>9</em>187-1:2010 are intended for single use only. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/53/55326","uuid":"f93d3099-bd2f-455d-807e-a533595f6bc0","title":"ISO 9151:2016 Protective clothing against heat and flame — Determination of heat transmission on exposure to flame","status":"Published","year":2021,"order":11,"text":"ISO 9151:2016 specifies a method for determining the heat transmission through materials or material assemblies used in protective clothing. Materials may then be ranked by comparing heat transfer indices, which provide an indication of the relative heat transmission under the specified test conditions. The heat transfer index should not be taken as a measure of the protection time given by the tested materials under actual use conditions. ","objectID":"55326_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>151:2016 Protective clothing against heat and flame — Determination of heat transmission on exposure to flame","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>151:2016 specifies a method for determining the heat transmission through materials or material assemblies used in protective clothing. Materials may then be ranked by comparing heat transfer indices, which provide an indication of the relative heat transmission under the specified test conditions. The heat transfer index should not be taken as a measure of the protection time given by the tested materials under actual use conditions. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/49/54927","uuid":"68220e78-9d8d-4d81-9496-bb2560bb7631","title":"ISO 9336-1:2010 Optics and photonics — Optical transfer function — Application — Part 1: Interchangeable lenses for 35 mm still cameras","status":"Published","year":2021,"order":11,"text":"ISO 9336‑1:2010 specifies a method of testing interchangeable lenses for 35 mm still cameras with a picture format of 24 mm x 36 mm in terms of imaging states aimed at making valid optical transfer function measurements. ","objectID":"54927_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>336-1:2010 Optics and photonics — Optical transfer function — Application — Part 1: Interchangeable lenses for 35 mm still cameras","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>336‑1:2010 specifies a method of testing interchangeable lenses for 35 mm still cameras with a picture format of 24 mm x 36 mm in terms of imaging states aimed at making valid optical transfer function measurements. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/41/54152","uuid":"dd6d6f48-2565-4437-a3bf-fa839dbd51d3","title":"ISO 9815:2010 Road vehicles — Passenger-car and trailer combinations — Lateral stability test","status":"Published","year":2021,"order":11,"text":"ISO 9815:2010 specifies a lateral stability test for passenger-car and trailer combinations. It is applicable to passenger cars in accordance with ISO 3833, and also to light trucks, and their trailer combinations. The lateral stability test determines the damping characteristic of the yaw oscillation of such towing-vehicle–trailer combinations excited by a defined steering impulse. The combination is initially driven in a steady-state, straight-ahead driving condition. Oscillation of the vehicle is then initiated by the application of a single impulse of steering, followed by a period in which steering is held fixed and the oscillation of the combination is allowed to damp out. Testing is conducted at several constant speeds. Where non-periodic instability is of interest, a steady-state circular test is specified. ","objectID":"54152_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>815:2010 Road vehicles — Passenger-car and trailer combinations — Lateral stability test","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>815:2010 specifies a lateral stability test for passenger-car and trailer combinations. It is applicable to passenger cars in accordance with <em>ISO</em> 3833, and also to light trucks, and their trailer combinations. The lateral stability test determines the damping characteristic of the yaw oscillation of such towing-vehicle–trailer combinations excited by a defined steering impulse. The combination is initially driven in a steady-state, straight-ahead driving condition. Oscillation of the vehicle is then initiated by the application of a single impulse of steering, followed by a period in which steering is held fixed and the oscillation of the combination is allowed to damp out. Testing is conducted at several constant speeds. Where non-periodic instability is of interest, a steady-state circular test is specified. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/53/5356","uuid":"edfb494d-bf91-4f78-98e1-12d975c9cad9","title":"ISO 937:1978 Meat and meat products — Determination of nitrogen content (Reference method)","status":"Published","year":2021,"order":11,"text":"The method consists in digesting of a test portion with concentrated sulphuric acid, using copper(II) sulphate as a catalyst, to convert organic nitrogen to ammonia ions. Then alkalisation, distillation of the liberated ammonia into an excess of boric acid solution, titration with hydrochloric acid to determine the ammonia bound by the boric acid, and calculation of nitrogen content of the sample from the amount of ammonia produced. ","objectID":"5356_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>37:1978 Meat and meat products — Determination of nitrogen content (Reference method)","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"The method consists in digesting of a test portion with concentrated sulphuric acid, using copper(II) sulphate as a catalyst, to convert organic nitrogen to ammonia ions. Then alkalisation, distillation of the liberated ammonia into an excess of boric acid solution, titration with hydrochloric acid to determine the ammonia bound by the boric acid, and calculation of nitrogen content of the sample from the amount of ammonia produced. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/53/5340","uuid":"cd1211de-91f1-4216-9bd2-8f1f6274ac50","title":"ISO 924:1989 Coal preparation plant — Principles and conventions for flowsheets","status":"Published","year":2021,"order":11,"text":"Sets out principles and conventions for use in preparation of basic process and equipment flowsheets for the design of a coal preparation plant. In order to cover the various stages leading to the final design of a plant, two basic flowsheets are needed, one bases on the process and the other on the equipment. Examples of process and equipment flowsheets are shown in figures. ","objectID":"5340_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>24:1989 Coal preparation plant — Principles and conventions for flowsheets","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"Sets out principles and conventions for use in preparation of basic process and equipment flowsheets for the design of a coal preparation plant. In order to cover the various stages leading to the final design of a plant, two basic flowsheets are needed, one bases on the process and the other on the equipment. Examples of process and equipment flowsheets are shown in figures. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/22/52246","uuid":"927fb7e4-5422-4623-8fde-c73950df0dcf","title":"ISO 9308-2:2012 Water quality — Enumeration of Escherichia coli and coliform bacteria — Part 2: Most probable number method","status":"Published","year":2021,"order":11,"text":"ISO 9308-2:2012 specifies a method for the enumeration of E. coli and coliform bacteria in water. The method is based on the growth of target organisms in a liquid medium and calculation of the \"Most Probable Number\" (MPN) of organisms by reference to MPN tables. This method can be applied to all types of water, including those containing an appreciable amount of suspended matter and high background counts of heterotrophic bacteria. However it must not be used for the enumeration of coliform bacteria in marine water. When using for the enumeration of E. coli in marine waters, a 1→10 dilution in sterile water is typically  required, although the method has been shown to work well with some marine waters that have a lower than normal concentration of salts. In the absence of data to support the use of the method without dilution, a 1→10 dilution is used. This method relies upon the detection of E. coli based upon expression of the enzyme b‑D‑glucuronidase and consequently does not detect many of the enterohaemorhagic strains of E. coli , which do not typically express this enzyme. Additionally, there are a small number of other E. coli strains that do not express b‑D‑glucuronidase. The choice of tests used in the detection and confirmation of the coliform group of bacteria, including E. coli , can be regarded as part of a continuous sequence. The extent of confirmation with a particular sample depends partly on the nature of the water and partly on the reasons for the examination. The test described in ISO 9308-2:2012 provides a confirmed result with no requirement for further confirmation of positive wells. ","objectID":"52246_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>308-2:2012 Water quality — Enumeration of Escherichia coli and coliform bacteria — Part 2: Most probable number method","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>308-2:2012 specifies a method for the enumeration of E. coli and coliform bacteria in water. The method is based on the growth of target organisms in a liquid medium and calculation of the \"Most Probable Number\" (MPN) of organisms by reference to MPN tables. This method can be applied to all types of water, including those containing an appreciable amount of suspended matter and high background counts of heterotrophic bacteria. However it must not be used for the enumeration of coliform bacteria in marine water. When using for the enumeration of E. coli in marine waters, a 1→10 dilution in sterile water is typically  required, although the method has been shown to work well with some marine waters that have a lower than normal concentration of salts. In the absence of data to support the use of the method without dilution, a 1→10 dilution is used. This method relies upon the detection of E. coli based upon expression of the enzyme b‑D‑glucuronidase and consequently does not detect many of the enterohaemorhagic strains of E. coli , which do not typically express this enzyme. Additionally, there are a small number of other E. coli strains that do not express b‑D‑glucuronidase. The choice of tests used in the detection and confirmation of the coliform group of bacteria, including E. coli , can be regarded as part of a continuous sequence. The extent of confirmation with a particular sample depends partly on the nature of the water and partly on the reasons for the examination. The test described in <em>ISO</em> <em>9</em>308-2:2012 provides a confirmed result with no requirement for further confirmation of positive wells. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/21/52197","uuid":"c63b3257-d4bf-45b1-a1ff-440267c401cd","title":"ISO 9149:2010 Cork wallcoverings in rolls — Specifications","status":"Published","year":2021,"order":11,"text":"ISO 9149:2010 specifies the requirements of cork wallcoverings in roll form to be used within buildings. ISO 9149:2010 contains provisions for the evaluation of conformity of the product. It also includes requirements for marking, packaging and labelling. ","objectID":"52197_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>149:2010 Cork wallcoverings in rolls — Specifications","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>149:2010 specifies the requirements of cork wallcoverings in roll form to be used within buildings. <em>ISO</em> <em>9</em>149:2010 contains provisions for the evaluation of conformity of the product. It also includes requirements for marking, packaging and labelling. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/19/51920","uuid":"4c239ae6-731a-4416-9398-a075334e0440","title":"ISO 9311-2:2011 Adhesives for thermoplastic piping systems — Part 2: Determination of shear strength","status":"Published","year":2021,"order":11,"text":"ISO 9311-2:2011 specifies a method for the determination of the shear strength of joints made with adhesives for thermoplastic piping systems. ","objectID":"51920_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>311-2:2011 Adhesives for thermoplastic piping systems — Part 2: Determination of shear strength","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>311-2:2011 specifies a method for the determination of the shear strength of joints made with adhesives for thermoplastic piping systems. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/15/51517","uuid":"968d9add-b9df-4563-825d-2b559d8c8a12","title":"ISO 9270-2:2010 7/24 taper spindle noses for automatic tool changers — Part 2: Dimensions and designation of spindle noses of forms J and JF","status":"Published","year":2021,"order":11,"text":"ISO 9270-2:2010 specifies the dimensions and tolerances of 7/24 taper spindle noses with tenons for automatic tool changers, intended for use with the corresponding tool shanks of forms J, JD and JF according to ISO 7388-2. ","objectID":"51517_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>270-2:2010 7/24 taper spindle noses for automatic tool changers — Part 2: Dimensions and designation of spindle noses of forms J and JF","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>270-2:2010 specifies the dimensions and tolerances of 7/24 taper spindle noses with tenons for automatic tool changers, intended for use with the corresponding tool shanks of forms J, JD and JF according to <em>ISO</em> 7388-2. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/09/50991","uuid":"b05637cb-5c6a-4097-b834-39142a600181","title":"ISO 9270-1:2010 7/24 taper spindle noses for automatic tool changers — Part 1: Dimensions and designation of spindle noses of forms S and SF","status":"Published","year":2021,"order":11,"text":"ISO 9270-1:2010 specifies the dimensions and tolerances of 7/24 taper spindle noses with tenons for automatic tool changers, intended for use with the corresponding tool shanks of forms A, AD, AF, U, UD and UF according to ISO 7388-1. ","objectID":"50991_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>270-1:2010 7/24 taper spindle noses for automatic tool changers — Part 1: Dimensions and designation of spindle noses of forms S and SF","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>270-1:2010 specifies the dimensions and tolerances of 7/24 taper spindle noses with tenons for automatic tool changers, intended for use with the corresponding tool shanks of forms A, AD, AF, U, UD and UF according to <em>ISO</em> 7388-1. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/00/50090","uuid":"111ae209-c20c-4917-9844-1e0729df0bee","title":"ISO 9039:2008 Optics and photonics — Quality evaluation of optical systems — Determination of distortion","status":"Published","year":2021,"order":11,"text":"ISO 9039:2008 specifies methods of determining distortion in optical systems for the purposes of quality evaluation. It applies to optical imaging systems in the optical spectral range from 100 nm to 15 000 nm which, by their design, aim at a rotationally symmetric image geometry. It is applicable to electro-optical imaging systems provided that adequate rotational symmetry of the image is guaranteed. It does not, therefore, apply to anamorphic and fibre optic systems. ","objectID":"50090_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>039:2008 Optics and photonics — Quality evaluation of optical systems — Determination of distortion","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>039:2008 specifies methods of determining distortion in optical systems for the purposes of quality evaluation. It applies to optical imaging systems in the optical spectral range from 100 nm to 15 000 nm which, by their design, aim at a rotationally symmetric image geometry. It is applicable to electro-optical imaging systems provided that adequate rotational symmetry of the image is guaranteed. It does not, therefore, apply to anamorphic and fibre optic systems. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/00/50033","uuid":"06de0add-2cb0-43e3-afff-ba4c7d3b738a","title":"ISO 9173-2:2010 Dentistry — Extraction forceps — Part 2: Designation","status":"Published","year":2021,"order":11,"text":"ISO 9173‑2:2010 specifies the designation of dental extraction forceps. ","objectID":"50033_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>173-2:2010 Dentistry — Extraction forceps — Part 2: Designation","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>173‑2:2010 specifies the designation of dental extraction forceps. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/00/50014","uuid":"8ac7eb82-91e1-47f4-b36d-f2ada97900be","title":"ISO 9241-129:2010 Ergonomics of human-system interaction — Part 129: Guidance on software individualization","status":"Published","year":2021,"order":11,"text":"ISO 9241-129:2010 provides ergonomics guidance on individualization within interactive systems, including recommendations on where individualization might be appropriate or inappropriate and how to apply individualization. It focuses on individualization of the software user interface to support the needs of users as individuals or as members of a defined group. It does not recommend specific implementations of individualization mechanisms. It provides guidance on how the various aspects of individualization are made usable and accessible, but does not specify which individualizations are to be included within a system. (Individualizations depend on the specific context of use for which an interactive system is to be designed and/or used, and need to be developed for that specific context of use.) ISO 9241-129:2010 is not intended to be used in isolation. It deals only with individualization within the context of designing a complete software system. It is intended to be used with ISO 9241-110 and any other parts in the ISO 9241 series applicable to the design of the intended system. Some of its guidance can also be applied to hardware user interfaces and user interfaces that combine software and hardware. ","objectID":"50014_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>9</em>241-129:2010 Ergonomics of human-system interaction — Part 129: Guidance on software individualization","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]},"text":{"value":"<em>ISO</em> <em>9</em>241-129:2010 provides ergonomics guidance on individualization within interactive systems, including recommendations on where individualization might be appropriate or inappropriate and how to apply individualization. It focuses on individualization of the software user interface to support the needs of users as individuals or as members of a defined group. It does not recommend specific implementations of individualization mechanisms. It provides guidance on how the various aspects of individualization are made usable and accessible, but does not specify which individualizations are to be included within a system. (Individualizations depend on the specific context of use for which an interactive system is to be designed and/or used, and need to be developed for that specific context of use.) <em>ISO</em> <em>9</em>241-129:2010 is not intended to be used in isolation. It deals only with individualization within the context of designing a complete software system. It is intended to be used with <em>ISO</em> <em>9</em>241-110 and any other parts in the <em>ISO</em> <em>9</em>241 series applicable to the design of the intended system. Some of its guidance can also be applied to hardware user interfaces and user interfaces that combine software and hardware. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","9"]}}}],"nbHits":4488,"page":0,"nbPages":10,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 9","params":"query=ISO+9&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":8}
508
+ http_version:
509
+ recorded_at: Tue, 26 Oct 2021 13:01:14 GMT
510
+ - request:
511
+ method: get
512
+ uri: https://www.iso.org/contents/data/standard/00/35/3589.html
513
+ body:
514
+ encoding: US-ASCII
515
+ string: ''
516
+ headers:
517
+ Accept-Encoding:
518
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
519
+ Accept:
520
+ - "*/*"
521
+ User-Agent:
522
+ - Ruby
523
+ Host:
524
+ - www.iso.org
525
+ response:
526
+ status:
527
+ code: 301
528
+ message: ''
529
+ headers:
530
+ Expires:
531
+ - Wed, 09 May 1979 05:30:00 GMT
532
+ Cache-Control:
533
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
534
+ Pragma:
535
+ - no-cache
536
+ Set-Cookie:
537
+ - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
538
+ Secure
539
+ - JSESSIONID=FE0588BC2AD19C64F5B5CB4263989925; Path=/; Secure; HttpOnly
540
+ Location:
541
+ - "/standard/3589.html"
542
+ Content-Length:
543
+ - '0'
544
+ Date:
545
+ - Tue, 26 Oct 2021 13:01:14 GMT
546
+ Strict-Transport-Security:
547
+ - max-age=31536000; includeSubDomains
548
+ body:
549
+ encoding: UTF-8
550
+ string: ''
551
+ http_version:
552
+ recorded_at: Tue, 26 Oct 2021 13:01:15 GMT
553
+ - request:
554
+ method: get
555
+ uri: https://www.iso.org/standard/3589.html
556
+ body:
557
+ encoding: US-ASCII
558
+ string: ''
559
+ headers:
560
+ Accept-Encoding:
561
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
562
+ Accept:
563
+ - "*/*"
564
+ User-Agent:
565
+ - Ruby
566
+ Host:
567
+ - www.iso.org
568
+ response:
569
+ status:
570
+ code: 200
571
+ message: ''
572
+ headers:
573
+ Expires:
574
+ - Wed, 09 May 1979 05:30:00 GMT
575
+ Cache-Control:
576
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
577
+ Pragma:
578
+ - no-cache
579
+ Set-Cookie:
580
+ - BIGipServerpool_prod_iso_www-jahia=747131274.36895.0000; path=/; Httponly;
581
+ Secure
582
+ - JSESSIONID=187303BBD590F3B2867E49B349A536D5; Path=/; Secure; HttpOnly
583
+ Vary:
584
+ - accept-encoding
585
+ Content-Type:
586
+ - text/html;charset=UTF-8
587
+ Transfer-Encoding:
588
+ - chunked
589
+ Date:
590
+ - Tue, 26 Oct 2021 07:01:16 MDT
591
+ Strict-Transport-Security:
592
+ - max-age=31536000; includeSubDomains
593
+ body:
594
+ encoding: ASCII-8BIT
595
+ string: !binary |-
596
+ <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 9:1995 - Information and documentation — Transliteration of Cyrillic characters into Latin characters — Slavic and non-Slavic languages</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/3589.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.5/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1627457321310" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.5/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1627457321310"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1630493922153"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20170309" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/00/35/3589.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 9:1995" />
    <meta property="og:title" content="ISO 9:1995" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Information and documentation — Transliteration of Cyrillic characters into Latin characters — Slavic and non-Slavic languages" />
    <meta property="og:description" content="Information and documentation — Transliteration of Cyrillic characters into Latin characters — Slavic and non-Slavic languages" />
    <meta name="description" content="Information and documentation — Transliteration of Cyrillic characters into Latin characters — Slavic and non-Slavic languages" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/home/about-us/strategy-2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/home/about-us/strategy-2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/3589.html">français</a></li><li><a href="/ru/standard/3589.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="3589 - ISO 9:1995 - Information and documentation — Transliteration of Cyrillic characters into Latin characters — Slavic and non-Slavic languages"></span>

  <span class="hidden" id="itemReference">ISO 9:1995</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">3589</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/01.html">01</a> >&nbsp;<a href="/en/ics/01.140.html">01.140</a> >&nbsp;<a href="/en/ics/01.140.10.html">01.140.10</a></div>
  

  <h1>ISO 9:1995</h1>
  <h2 class="no-uppercase">Information and documentation — Transliteration of Cyrillic characters into Latin characters — Slavic and non-Slavic languages</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

    <section class="bg-lightgray section-sm">
      <div class="container">
        <div class="row">
          <div class="col-md-7">
            <h3 role="alert" class="no-margin">
              This standard was last reviewed and confirmed in&nbsp;2017.
              Therefore this version remains current.
            </h3>
          </div>
        </div>
      </div>
    </section>
  
<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:3589:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>Cancels and replaces the first edition (1986). Establishes a system for the transliteration into Latin characters of Cyrillic characters constituting the alphabets of Slavic and non-Slavic languages. Table 3 includes in a single sequence, listed in the Cyrillic alphabetic order, the 118 single or diacritic-carrying characters that appear in one or another of the considered alphabets.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/00/35/3589.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">1995-02</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 2
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 13
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/48750.html">ISO/TC 46</a>
        </div>
        <div class="entry-title">Information and documentation</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/01.140.10.html">
                01.140.10
            </a>
          </div>
          <div class="entry-title">Writing and transliteration</div>
        </dd>
      
    </dl>
  </li>
</ul>

    <div class="sdg-box">
      
      <p>
        <img loading="lazy" src="/files/live/sites/isoorg/files/data/sdg/en/sdg-logo.png" class="img-responsive width-100pct width-300" alt="Sustainable Development Goals" />
      </p>
      <p>
        This standard contributes to the following <a href="/sdgs.html">Sustainable Development Goal</a>:
      <p>
      <div class="clearfix">
        
          <a href="/sdg/SDG04.html" title="Quality Education">
            <div class="sdg sdg-sm sdg-04">
              <div class="sdg-icon"></div>
              <div class="sdg-label">4</div>
              <div class="sdg-text">Quality Education</div>
              <div class="sdg-logo"></div>
            </div>
          </a>
        
      </div>
    </div>
  
      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">88</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub00000028LvEAAU~a05b0000005WV2ZAAW~a0fb0000000ehNlAAI~a0cb0000001QlhFAAS" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub00000028LvEAAU~a05b0000005WV2ZAAW~a0fb0000000ehapAAA~a0cb0000001QlhKAAS" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">88</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                Paper
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub00000028LvEAAU~a05b0000005WV2eAAG~a0fb0000000ehafAAA~a0cb0000001QlTrAAK" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub00000028LvEAAU~a05b0000005WV2eAAG~a0fb0000000ehakAAA~a0cb0000001QlXZAA0" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">88</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Previously</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Withdrawn</div>
                    <h5><a href="/standard/3588.html">ISO 9:1986</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                  <div class="step step-success active">
                    <div class="section-head">Published</div>
                    
              <h5>ISO 9:1995</h5>
                  <br/>A standard is reviewed every 5 years<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>90.93</strong> (Confirmed)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#30_00">
                              <span class="stage-code">30.00</span>
                              <span class="stage-date">1972-01-01</span>
                              <div class="stage-title">
                                Committee draft (CD) registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_20">
                              <span class="stage-code">30.20</span>
                              <span class="stage-date">1982-06-01</span>
                              <div class="stage-title">
                                CD study/ballot initiated
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#30_99">
                              <span class="stage-code">30.99</span>
                              <span class="stage-date">1982-11-01</span>
                              <div class="stage-title">
                                CD approved for registration as DIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">1972-02-01</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">1975-04-01</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">1975-11-01</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_92">
                              <span class="stage-code">40.92</span>
                              <span class="stage-date">1977-09-01</span>
                              <div class="stage-title">
                                Full report circulated: DIS referred back to TC or SC
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_00">
                              <span class="stage-code">40.00</span>
                              <span class="stage-date">1992-06-11</span>
                              <div class="stage-title">
                                DIS registered
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_20">
                              <span class="stage-code">40.20</span>
                              <span class="stage-date">1992-06-25</span>
                              <div class="stage-title">
                                DIS ballot initiated: 12 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#40_60">
                              <span class="stage-code">40.60</span>
                              <span class="stage-date">1993-02-09</span>
                              <div class="stage-title">
                                Close of voting
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">1993-10-12</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">1994-09-30</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">1994-09-30</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">1995-02-23</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#90_92">
                              <span class="stage-code">90.92</span>
                              <span class="stage-date">1998-05-14</span>
                              <div class="stage-title">
                                International Standard to be revised
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2001-07-18</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2005-11-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2006-07-15</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2006-07-15</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2011-07-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2011-12-17</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date">2016-10-15</span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_60">
                              <span class="stage-code">90.60</span>
                              <span class="stage-date">2017-03-08</span>
                              <div class="stage-title">
                                Close of review
                              </div>
                            </a>
                          </li>
                          <li class="active">
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date">2017-03-09</span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li  class='list-separation'>
                            <a href="/stage-codes.html#90_20">
                              <span class="stage-code">90.20</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard under systematic review
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                      </a>

                      
                    </li>
                  
              </ul>

                  
            </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/01.html">01</a></li>
    
      <li><a href="/en/ics/01.140.html">01.140</a></li>
    
      <li><a href="/en/ics/01.140.10.html">01.140.10</a></li>
    <li>ISO 9:1995</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.5/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
597
+ http_version:
598
+ recorded_at: Tue, 26 Oct 2021 13:01:17 GMT
599
+ recorded_with: VCR 5.0.0