hash stringlengths 32 32 | doc_id stringlengths 5 12 | section stringlengths 5 1.47k | content stringlengths 0 6.67M |
|---|---|---|---|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 3.3 Abbreviations
| For the purposes of the present document, the abbreviations given in TR 21.905 [1] and the following apply. An abbreviation defined in the present document takes precedence over the definition of the same abbreviation, if any, in TR 21.905 [1].
WYSIWYG What You See Is What You Get
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 4 Assessment of existing specification formats and working methods, and requirements for any improvements
| Editor's note: corresponds to objective 1.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 4.1 Benefits of current tools
| These benefits may in future be achieved by other means than the current tools and file formats used.
1. Familiarity
The current set of tools are well known to delegates. 3GPP TR 21.801 [2] captures all requirements and recommendations, accumulated since 1999. Further, there is institutional expertise in checking that this is done properly (each secretary, MCC, other delegates, etc.) There are company internal and external tutorials for new delegates to assist coming up to speed.
There is a complete 'way of working' built around the tools that is well known and stable, including interactions between delegates and group leadership, submission, retrieval during and after meetings, databases to track actions, etc.
NOTE 1: There is a limitation to this benefit as institutional expertise in checking proper use of drafting rules is quite inconsistent amongst those who create and edit CRs. Additionally, features which appear to be simple, such as applying the correct style and verifying the correct style, ensuring the correct style when copying and pasting, and correctly applying changes with track changes turned on, are quite error prone.
2. Integration
(Nearly) all content for CRs and specifications are integrated into a single file that can be edited, viewed, sent to others, without any concern for capturing all of the content of the document (e.g. each figure). This makes it extremely easy to work collaboratively to incrementally collect feedback and share proposed changes on a document under discussion and revision.
NOTE 2: There is a limitation to this benefit, as continuing work and discussion of a CR involves multiple copies of the document (e.g. in the INBOX DRAFTS folder with only a manual effort approach to keep them in sync). Discussions on the basis of such divergent documents is difficult to follow.
Content can also be directly pasted into the document from external applications. For some formats, the metadata required to edit the figure is also included, e.g., MSC-Generator block diagrams and call flows include the image representation and the source representation when pasted into a document.
To the extent that there are other files needed, e.g. source code attachment in the form of YAML, JSON, XML, etc., these are collected in the same zip file that is used to store & retrieve, share and review, etc.
NOTE 3: There is a limitation to this benefit as the integration doesn't work well on all platforms. In particular, MSC-Generator (and any other format, e.g., Visio) diagrams embedded with OLE are not editable on any platform other than MS Windows and it may experience rendering issues when displaying. It shall be noted it is not only related to the OLE embedding but also the lack of programme/application for other OS.
3. WYSIWYG Editing and Ease of Use
The content of the document appears as it will in the final product. This view is exact when change marks are not shown.
When change marks are shown, the document is shown with close to final results, though the removed material is also displayed. Changes on changes, if shown at all, are used only for draft documents, removed in the submitted CR, but this is used in on-line work in some groups (see benefit 16 below).
NOTE 4: Changes on changes are not trivial to remove once introduced. 3GPP delegates, leaders and secretaries are familiar with this view and can work with it rapidly to identify what has changed and whether it is acceptable (especially, whether it addresses past comments). See Change Marking below.
WYSIWYG editing is easy to use. There is only one tool to learn for most editing tasks, (except for figure and equation editing, which can support use of external tools such as visio).
Also, WYSIWYG editing in the current tools allows editing directly in the document of content that has been embedded, such as equations, figures, diagrams, tables, etc. which is especially useful. This edited content appears at all times as it will in the final resulting version.
NOTE 5: There is a limitation to this benefit as MS Word is in fact a very complex software and even experienced delegates sometimes struggle with some of its features. Furthermore, when something goes wrong (in a large document with complex styles), it is extremely hard to figure out the source of the problem.
NOTE 6: Another limitation is that editing figures directly in the document embedded with OLE is not supported on any platform other than MS Windows and such figures may not render correctly. (See also NOTE 3 of benefit 2)
4. Proofing Tools
For many delegates English is not their primary language. For them, the spelling and grammar checks are quite helpful, as well as the automatic proposals for replacement of words and grammatical correction of phrases.
5. Change Marking
Change marks show added, removed, and moved text. They capture more than one change in a way that makes it immediately visible that changes are distinct. It is possible to view the metadata associated with the change (who did it, when, what the text of the change was, etc.)
It is possible to adjust the 'source' of the change marks, as this could be the name of the delegate, company, work item code, CR number, etc. in different ways of working scenarios, employed in 3GPP groups.
Additionally, draft specifications show change marks and a comment indicating from which CR submitted to plenary a change originated.
NOTE 7: There is a limitation to the benefit of change marking when applied to the task of implementing a CR in a specification on the basis of change marking, which has proven very difficult to automate.
NOTE 8: There is a limitation to the benefit of change marking as it does not capture some changes, especially details of changes to figures, tables and other more complex content. Some formatting changes are also not captured as changes. Removing empty lines can also result in unexpected behaviour such as applying the style of the text beneath the empty line to the text above the empty line once the empty line is deleted.
NOTE 9: There is a limitation to the benefit of change marking as track changing can be turned off, and changes can be discarded or accepted by any author without leaving traces.
6. Extensive Formatting
It is possible to format tables, figures, text, text colouring, and other content easily, with integrated help facilities to assist. Some of these operations are complex in principle (e.g. merging or splitting cells, greying parts of cells, etc.) though these are straightforward in terms of usability with the current tools.
NOTE 10: Highlight formatting is not strictly allowed by the drafting rules TR 21.801, but used extensively and found to be highly useful to emphasize certain changes in the drafting phase of a specification and for documents under discussion, etc.
NOTE 11: There is a limitation to this benefit as overly complex text formatting, which a document can end up with (sometimes inadvertently), significantly contributes to the slowness of editing and even viewing it.
7. Consistent Output
The current tools and formats have allowed 3GPP specifications to have a consistent appearance across thousands of publications, new and old.
8. Integrated means for collaboration
It is possible to embed comments (also known as 'comment bubbles') and replies to comments directly in documents. This is often used by participants in 3GPP to share their views during the revision and off-line discussion of documents. Though this is not used in any formal 3GPP document process, it remains a useful tool for organizations to share individual comments and questions both internally and externally.
Additionally, online collaboration is possible internally to a company during the drafting phase depending on the docx editing tool and file sharing system in place.
NOTE 12: There are limits to this benefit, as it does not scale up well to allow large numbers of comments or commenters.
NOTE 13: There is a limit to the way of working in which comments are shared in the form of documents with comments using ftp, email, etc. It is very difficult to coordinate this activity and keep track of all comments: either comments are collected in a single document which 'forks' unintentionally, or multiple documents must be collected and read without 'order' in the discussion (making it hard to properly reply to others' comments, be aware of all comments made, etc.)
9. Ability to control the page orientation
For tables that are very wide, it is very useful to reorient specific pages to landscape. This requires insertion of 'sections' in Microsoft Word.
10. Ability to capture significant common information in templates
Templates capture common styles, defaults, page width and height, headers, footers, etc. This makes it possible to achieve Consistent Output (see benefit 7 above).
NOTE 14: There is some limit to this benefit, since it is possible to ignore the template either through improper configuration of MS Word (e.g. the wrong language setting), or unintentionally, through pasting content into a document from a document with different properties and settings, that does not use the template, etc.
11. Product support and licensing
The current tools have professional support, are licensed and sold at reasonable prices globally and are sufficiently stable to work with. There are even (open source tool) options available that are compatible without licensing fees.
NOTE 15: There is a limit to this benefit, as some versions of tools used to read and write DOCX work slightly differently. In particular, embedded object editing support and Visio is only available on computers running Windows and such embedded objects may not be rendered correctly .
NOTE 16: The availability of some tools over time changes, and the affordability and stability of commercial tools depends on the perspective of the organization that participates in 3GPP.
12. Ease of conversion of format
It is easy to convert a MS Word document to PDF, among other formats.
NOTE 17: There is a limit to this benefit, as conversion to PDF sometimes fails (for reasons unknown).
13. Offline editing
Current tools and the associated file formats, principally MS Word and DOCX format files can be used off-line. TDocs and CRs can be downloaded in advance and read and edited locally.
14. Document navigation
Docx supports hierarchical headings which can be used by many docx editors to show an interactive table of contents for quick document navigation.
NOTE 18: There is a limit to this benefit, as large DOCX documents often need to be split into multiple files, which hampers navigation.
NOTE 19: There is a limit to this benefit, as the navigation requires proper application of header styles, which is not always the case for various reasons. (See benefit 6. Extensive formatting above and also NOTE 5 of benefit 3 above)
15. Simple access to documents
Specifications and TDocs, including CRs, are easily accessible through a web portal and through an FTP client. Specifications are also available in a structured way, e.g., by series, which also lists all the version numbers per specification.
NOTE 20: For TDocs and CRs, this benefit is limited to the access, and the benefit falls short when searching for a specific document. That is, searching for the TDoc explaining the reason a change was made remains difficult. There is some disagreement about whether ftp use is 'simple' (it may be difficult to find a tdoc on the ftp file tree for past meetings, etc.)
NOTE 21: This benefit concerns the current 'document-centric way of working' in 3GPP and does not specifically relate to any document format, e.g. DOCX.
NOTE 22: The use of FTP is not allowed by some organizations as it is considered insecure.
NOTE 23: FTP is not the most efficient way to constantly synchronize a remote folder with documents (e.g. during a 3GPP meeting) to a delegate's computer. It requires constant manual downloading which takes time (sometimes a time of a chair during an online session to get the latest documents) and overloads the local network.
16. Ease of consensus building during meetings
During the meetings, both during online and offline sessions a lot of editing of the CRs happens whilst the changes are displayed directly on the screen. This is done by the chairs, rapporteurs, and offline moderators to capture comments made on the floor and to display the corresponding changes at the same time on the screen, including figures, equations, and tables. This is an important benefit of the current tools that improves meeting efficiency and is enabled by the WYSIWYG nature of the current tools.
NOTE 24: There is a limit to the extent that change marks can be captured on figures, equations, tables, etc. Change marking is not the benefit described above, rather collectively viewing and participating in editing sessions to reach consensus decisions on modified draft documents rather than already submitted documents.
17. Copy and paste content from CRs to other documents is possible. Chair notes, session notes, discussion papers, and other documents include content from CRs. It is beneficial to be able to reproduce the content of CRs with the same appearance in other documents easily. It is also beneficial (somehow essential) that the same format is used for CRs as specifications.
NOTE 25: There is a limit to this benefit, as the paste of content into a CR sometimes results in unexpected configuration and styles and other diverse formatting issues: MS Word will sometimes apply the style of the area being pasted into. The different options: keep source formatting; merge formatting; and keep text only are not always sufficient for maintaining the correct style, and are complex so easy to apply incorrectly.
18. The use of git brings benefits: testing of cross referencing across YAML files (text only) before publication. Cross referencing has proven beneficial also for the development of OpenAPIs. Use of 3GPP Forge hosting allows content (including OpenAPIs) to be stored without use of zip files.
NOTE 26: This is not the common practice in 3GPP as a whole as of now.
NOTE 27: There is a limit to this benefit, as it is only used by a few WGs. Tdocs that use solely DOCX format CRs do not benefit.
19. The use of Excel has proven useful for storage of large tables, which have proven problematic when included in DOCX files. It is also possible to include computation across multiple cells in the table, e.g. for test tolerances, measurement uncertainties and link budget calculations.
NOTE 28: This is not the common practice in 3GPP as a whole as of now.
NOTE 29: Storage of some content of CRs in a separate file eliminates benefit 2. "Integration."
20. Macros for batch processing are beneficial, e.g. to identify style errors, editorial errors, in ASN.1 review for comment collection. Macros are also used for local document manipulation or concurrent manipulation of different documents.
NOTE 30: This benefit is present in MS Office applications, but the actual benefit is not the use of visual basic (which has disadvantages as a scripting language). Rather, the benefit is that there is a means to use scripts to process 3GPP documents, e.g. CRs, TRs, TSs and drafts thereof.
NOTE 31: There is a limit to this benefit, as VBA macros are not cross platform (many Word VBA features are not available on platforms other than MS Windows). Furthermore, some organizations prohibit using macros.
21. The ability to visualize different parts of a document (i.e. Split View) at the same time on the same screen is beneficial.
22. The ability to open and visualize several documents at the same time on the same screen is beneficial.
NOTE 32: One caveat to opening several documents at the same time is that with a popular docx editing tool, every window of the application is associated with all the others, so if one crashes, they all crash.
23. For their intended purpose in 3GPP, MS Office tools can be considered both natively secure i.e. robust to manipulation of source code, and systematically available (i.e. usable)
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 4.2 Shortcomings, pain-points and potential benefits
| Editor’s note: corresponds to objectives 1a/b
Table 4.2-1: Shortcomings, pain-points and potential benefits of current tools
#
Shortcoming / pain-point / potential benefit
Possible improvement approaches with current tools
Summary of feasibility of addressing the shortcoming / pain-point / potential benefit with current tools
Applicable WGs and users of the specification
1
Delays in specification availability Specifications are not available until after the TSG plenaries, sometimes very close to submission deadlines for the next WG meeting. Thus, writing new CRs is delayed or CRs are written based on an old version. There is also limited time for review of the merged spec.
Solution 1/1A –- Increase workforce for CR merging
Solution 2 –- Scripting to automatically merge CRs
Partly feasible –- Solution 1/1A for decreasing the number of TSes handled by a single MCC officer with the caveat that even a single large specification with many CRs still takes time to handle, while there are drawbacks about redistributing the load from MCC to delegates who would take on some of the work. Solution 2 (maybe feasible) is being developed for ETSI, but its feasibility is unknown.
WGs
All groups
Users
Consumer, Contributor, Editor
2
CR cover page errors
Errors can be present in the cover page details such as specification number and version, date, release, CR revision, affected clauses, and changes are not reflected in database
Solution 3 –- [New tool] CR conformance checking
Solution 4 –- [New tool] CR auto-generation
Solution 5 –- CR cover auto-generation
Maybe feasible –- Solution 5 is available and can be useful if the cover page is generated and attached to the CR just before submission. Solution 3 is being developed for ETSI (new CR parser that will perform a number of verifications on CR cover fields and also verify that the clauses affected listed on cover correspond to the actual changes. The parser will be available on-demand and run upon CR upload). Solution 4 would solve the problem, but the tools do not exist.
WGs
All Groups
Users
Contributor, Editor
3
CR content errors
- Incorrect specification base text, e.g., from the incorrect version
- Errors introduced by copying and pasting content such as additional sections
- Errors introduced by copying a CR for a later release to mirror CRs for prior releases
- Unused references, e.g., references that are used but not defined, or defined which are not used, and references to non-existent clauses
- Incorrect use of styles, including manually applying text formatting to mimic a style
- Use of different settings in the docx editor such as language can lead to inconsistent formatting and styles which diverge from the official template
- Omission of trademarks, commercial references, etc.
Solution 3 –- [New tool] CR conformance checking
Solution 4 –- [New tool] CR auto-generation
Solution 6 –- Restrict editing
Solution 7 –- Training
Solution 8 –- Light version of Microsoft Word
Solution 9 –- EditHelp Consulting from ETSI
Solution 10 –- Exhaustive analysis of docx files against 21.801
Not feasible - Solutions 4 and 8 require new tools, which need to be written. Today they are infeasible since they do not exist. Solutions 7, 9, and 10 resolve parts of the issues, and are already done today and we still have the problems.
Maybe feasible –- Solution 6 could be feasible to resolve the style errors as long as everyone uses Microsoft Word.
Solution 3 is under development by ETSI in a new CR parser as indicated in solution 3 of shortcoming #2. The new CR parser will carry out a number of verifications, including use of latest reference version, no changes done without revision marks, or styles.
(NOTE 3)
WGs
All Groups
Users
Contributor, Editor
4
CR Merging
- Multiple changes to the same section sometimes remove specification text due to human errors.
- It is not possible to easily check the effect of the implementation of more than one CR or pCR simultaneously to check for side-effects
- It isn’t trivial to identify conflicting CRs such that the relevant experts, e.g., CR editors or WI rapporteurs, could discuss the appropriate resolution.
- Implementation of a CR is a manual process
Solution 2 –- Scripting to automatically merge CRs
Maybe feasible –- if the tool would be available for all specification contributors and editors, then it would be possible to check the effect of CRs.
A pilot tool by ETSI that detects CR clashes is currently in trial in some of the 3GPP WGs (e.g., CT3), This assists rapporteurs to facilitate resolution of clashes during the meeting rather than during CR implementation. Further development of the tool is in progress based on the feedback of the pilot
Furthermore, an automated CR implementation tool is being developed by ETSI.
WGs
All groups
Users
Contributor, Editor
5
CR Tracking
- It is difficult to associate a spec change with a CR, e.g., to determine where a change came from between two non-contiguous versions of a specification. For example, something changed between 18.1 and 18.7, but the exact version is unknown.
- CRs which are part of mega CRs or aggregate CRs are not visible individually in the draft spec.
- Changes to CRs to resolve merging conflicts, including those present in tables, ASN.1 definitions, and other text conflicts are not identifiable.
- Checking implementation of CRs is a manual process
- Missing background information on how certain test steps or approaches (pertaining to test parameters or implementation) were adopted for in conf test procedure
WGs
All groups
Users
Consumer, Contributor, Editor
5A
Feature Tracking
- It is difficult to track how a feature evolves across specification versions and releases. Furthermore, it is also difficult to track how corrections are introduced into a feature. This is particularly difficult for implementors who don’t reads a [new version of a] spec as a whole, but rather track how a particular feature evolves.
- Features are scattered across various sections of different TSs and the current tools don’t allow a way to “connect” those.
(NOTE 4)
WGs
All groups
Users
Consumer
6
Data Structure Styling, Syntax and Representation
- APIs and data structures, e.g., ASN.1, can contain formatting errors such as indentation for readability and colorization of keywords.
- Code-like and data model or table representations coexist and can be inconsistent, e.g., ASN.1, OpenAPI and XML in tabular form can be inconsistent and don’t match the code representations.
- OpenAPI: Different WGs (e.g. CT4 and SA5) often use the same datatypes but they are defined slightly differently.
- In some groups, when modifications are made during a meeting, syntax errors can be introduced due to lack of verification.
- In some groups, the contributions to the meeting can include syntax errors.
- It isn’t easy to extract code
Solution 11 –- Externalization of APIs and data structures
Solution 12 –- Single representation of APIs and data structures
Solution 13 –- Automatic syntax checking
Feasible –- Solution 11 is already used by some WGs to store certain data structures and APIs separately from the specification, e.g., RAN4, CT4, and SA5. Solution 12 is already used in RAN2 which moved away from tabular ASN.1.
Maybe Feasible –- Solution 11 could be adopted. Groups such as RAN2 and RAN3 include field definitions and descriptions of conditionals in field tables. A solution for storing the field descriptions, which contain normative text, needs to be devised. Additionally, many find it convenient to have the procedures and protocol definitions in the same document.
Solution 13 would require new scripting to extract text from the specification and run the syntax checker.
WGs
All groups
Users
Consumer, Contributor, Editor
7
Cross-specification reference and navigation
- References to other specification documents are made using numbered references in square brackets and are sometimes accompanied by a section or clause number.
- Navigating across a work item over multiple specifications and working groups can be time consuming. For example, a RAN2 procedure could be triggered by RAN3 procedure, triggered by an SA2 procedure.
- Conformance Test specifications use heavy cross-referencing between the test spec (e.g. 38.521-1) and associated details in test point analysis (TR 38.905), MU/TT (TR 38.903), UE/UE connection diagrams (TS 38.508-1)
Solution 14 - Include the specification number and clause number in references
Solution 15 –- Use hyperlinks in references
Solution 16 - Script to create, validate, and automate verification of cross-references between specifications
Partly Feasible –- Solution 14 at least solves the problem of accurately referencing another specification or the same specification. This solution is both inconvenient and prone to errors.
Infeasible –- Solution 15 –- while feasible, links would be to zip files hosted on the 3GPP FTP server. These would have to be unzipped, which is inconvenient, and the reference could not be to a specific clause. This (links to a server) would not work offline, so the solution is infeasible. Solution 16 doesn’t exist.
WGs
All groups
Users
Consumer, Contributor, Editor
8
Figures can become impossible to edit
- Occasionally, CRs convert Visio figures to a format which cannot be edited. Sometimes Visio figures are drawn in an older format.
- MSC-Generator diagrams can become corrupt
Solution 17 –- Store figure source files
Maybe feasible –- Solution 17 is feasible in the current tools because figure source files could be attached in the zip files. However, specifications can contain dozens to hundreds of figures, which could lead to error in omission of files and could be unscalable. Additionally, each attached file would have to be individually opened.
WGs
All groups
Users
Contributor, Editor
9
Quality and size of figures
- Some specifications and TRs include many images or a large body of text which can contribute significantly to the size of a docx file, leading to high upload and download times.
- Figures are resized in dimension or compressed, thereby being distorted.
- Microsoft has disallowed usage of equation editor 3.0 due to security issues with equation editor. When opening equations that were originally written using equation editor are stored as rasterized pixel images. Such images have image distortion issues when resizing the scale of the view.
Solution 18 –- Store images as vector graphics
Feasible –- Solution 18 is feasible for non-equation graphics.
WGs
All groups
Users
Contributor, Editor
10
Inconsistent use of tools and formats for figures
- e.g., Word, Visio, MSC-Generator, PlantUML, MS paint, PowerPoint, Equation editor, Latex, etc.
Solution 19 - Support a limited number of supported formats which work across WGs
Feasible –- Solution 19 would consider tools supported by the overall specification format, so they would be compatible.
(NOTE 1)
WGs
All groups
Users
Contributor, Editor
10A
Use of non-cross platform tools
- Some specifications use tools and formats (e.g. Visio) which are not available on platforms other than MS Windows.
- All specifications include figures
Solution 17 –- rely exclusively on native Word diagrams
Solution y –- include source files separately
Solution 19 - stop using non-cross platform tools, use cross platform tools instead (svg editors)
Partly feasible –- solution 17 is likely to reduce the capability to draw some diagrams, which may or may not be accessible, solution y is somewhat inconvenient but works.
Feasible - Solution 19 might result in a loss of features and look but the results using other tools can be similar. If the right tools are chosen, no local installation is needed. Some tools offer web based services, requiring a browser, only.
WGs
All groups
Users
Contributor, Editor
11
Large tables are not handled well - MS word does not handle large tables well and large documents well - can cause MS Word to crash or operate slowly.
Solution 11 –- Externalization of APIs and data structures
Solution 25 –- Split large specifications into smaller parts
Maybe feasible –- Solution 11, depending on the nature of the table’s content, it could be externalized, e.g., as in RAN4 for Carrier Aggregation (table content stored in JSON files on the 3GPP FORGE, combined with companion tools for conversion, visualisation or export).
Partly Feasible –- Solution 25 is used today, but it harms specification navigation, browsing and search.
WGs
All groups
Users
Consumer, Contributor, Editor
12
Collaboration on CRs
- Limitations of change tracking include: specific changes to figures are impossible to see; change marks not shown for columns deleted from tables; change marks are not shown when merging or unmerging cells; and change marks are shown in different colors, which poses an accessibility issue.
- Collaborative editing relies on downloading a document, providing input, and uploading it. There is a race condition when multiple delegates are working at the same time.
- Commenting bubbles do not scale well and having too many which affect the same clause makes it impossible to read.
- It is difficult to update documents when used to collect input since manual locking does not work and progress becomes slow and error prone
Solution 20 - Provide comments on CRs in a separate file instead of using bubble comments
Solution 21 –- Use NWM to collect comments
Solution 22 - Extract text under review and use Git to manage reviews
Solution 23 - Use FTP to download latest inputs and upload new inputs
Solution 24 - Split the CR for review into multiple files
Infeasible –- Solution 20 and 21 could become unscalable when commenting on a large CR with a large number of comments and responses. Solution 22 would cause the loss of content most likely and would result in an inaccurate review.
Maybe feasible –- Solution 23 is used today, but many companies may be restricting access to FTP and SFTP.
Partly Feasible –- Solution 24 could also work, but it has problems similar to Solution 23 and could increase confusion.
WGs
All groups
Users
Contributor, Editor
13
Specification opening and navigation delay
- Opening a TR or TS of 100s or 1000s of pages can take many minutes or even be impossible due to crashing.
- Searching with keywords can be slow.
- The specifications are stored as ZIP files, which add another step to opening the specification.
- There seems to be some issue in the .docx specification template itself, regarding the header that appears on top of each page which checking for every single page how the header should be filled even if there is only one outcome.
Solution 6 –- Restrict editing
Solution 7 - Training
Solution 8 –- Light version of Microsoft Word
Solution 11 –- Externalization of APIs and data structures
Solution 25 –- split large specifications into smaller parts
Solution 26 - Open specification and change to draft mode
Solution 27 - Produce 3GPP PDF version of the specification after each plenary
Solution 28 - Make all specs available in HTML
Infeasible: Solution 7: training does not preclude the possibility that Microsoft Word automatically applies styles, while training can draw people's attention on such matter and explain how to find erroneous styles and correct them.
Maybe feasible –- Solution 6, Solution 8 could help solve the problem, but so far these have not resulted in faster loading specs. Solution 25 works but has downsides like lack of navigability. Solution 26 works once the document is open, but crashing can occur prior to being able to switch to draft mode. Solution 28 may be infeasible because the conversion of Word to HTML could be lossy.
Partly Feasible –- Solution 27 is already done by ETSI and other SDOs, but 3GPP could possibly release a version more quickly. This may solve the issue for consumers, but not for contributors and editors (NOTE 2)
Feasible –- Solution 11 would make the specifications smaller and rendered more quickly, by code or complex content (e.g. content of large tables converted to JSON+FORGE as currently considered in RAN4) outside of the specification docx file (external attachment or FORGE repository).
WGs
All groups
Users
Contributor, Editor
14
Numbering of PRs and CPRs
- Potential Requirements (PR), Consolidated Potential Requirements (CPR), requirements are numbered manually and inconsistently within TR/TS, making it error prone for tracking or later reference.
- In some groups, requirements are not numbered which makes reference to requirements very difficult - it must be done by copying the text of the requirement. This can become misaligned, if the text is corrected in the specification where it is a provision.
Solution 29 –- Mandate the numbering of requirements (PR and CPR)
Feasible –- In Solution 29, numbering just needs to be enforced.
15
Automatic processing of specifications
- Access from automated text processing tools, e.g., Automata, to CRs and TSs/TRs is very cumbersome, requiring a lot of preprocessing and manual intervention
The docx format is not easily processed. The file format is a mix of text and binary (to store images and objects). Conversions, e.g., docx to markdown, do not produce perfect representations of the original docx.
WGs
All Groups
Users
Contributor, Editor
16
Use of FTP
FTP is not the most efficient protocol for constant synchronization of folders, e.g. during meetings.
Solution x –- a more modern and efficient tool and protocols (e.g. rsync) can be used instead of FTP
Maybe Feasible –- solution x can be implemented.
WGs
All Groups
Users
Contributor, Editor
NOTE 1: This could also solve pain-point 8 depending on what is chosen.
NOTE 2: No solution has been provided for how to deal with ZIP files.
NOTE 3: It has been noted that some of the errors are due to not following the process. It should be considered which of these errors could be prevented by following rules and whether it is feasible to enforce the following of such rules.
NOTE 4: This is different from “CR tracking” as CRs deal with a resolution of a WI, not a feature.
Editor's Note: Solutions for #10A and 16 in Table 4.2-1 is to be elaborated with more detail (possibly with new rows) in Table 4.2-2.
Table 4.2-2: Possible improvement approaches with current tools
#
Possible improvement approaches with current tools
Pros of possible improvement approaches
Cons of possible improvement approaches
Implementation Feasibility Analysis
1
Increase MCC workforce for CR merging –- In WGs where all CR merging is done by a single MCC officer today, there is the possibility to:
- Increase the MCC staff for CR merging.
Drastic decrease in the workload for MCC officers, reduces the need to look for automated tools for merging CRs into specs.
1A
Increase delegates workforce for CR merging –- In WGs where all CR merging is done by a single MCC officer today, there is the possibility to:
- Offload this task to each spec rapporteur. 3GPP could provide regular training courses for delegates that are candidates to become TS rapporteurs.
Increase in workload for delegates. Need to ensure that all TS rapporteurs complete the task timely and respect all 3GPP drafting rules with proper and regular training.
2
Scripting to automatically merge CRs –- ETSI is having a tool developed to automatically merge CRs into the specification.
Reduces human error and decreases the time to produce a merged specification.
It is unknown if such a script could be released to delegates and if it would comply with company security policies. For example, if macros are used, many would not be able to run them.
3
[New tool] CR conformance checking –- write a new tool to check and report the location and nature of errors in a CR. These errors could include style errors, non-contiguous clause numbering, non-conforming figure and table numbering, and mismatches between the CR database and the CR cover page.
By using the tool pre-submission, delegates would not experience delays in submission and less time would be spent during meetings discussing styles and formatting.
It is difficult to write and maintain consistent tools based on docx due to high variability in docx file structures.
Ensuring that styles didn’t change between versions and ensuring that the correct approved styles are used could be challenging and encounter corner cases.
4
[New tool] CR auto-generation - Write a tool, e.g., an application-native script, Python script or other programming language-based tool to automatically create a CR from a modified version of a specification, including the following:
- Auto-filled cover page including the specification number, specification version, and affected clauses
- Automatic inclusion of affected clauses in the body of the CR, including change marks
- Additionally, the macro would need to be available for local use such that delegates could check their CRs prior to submission.
- Many error-prone fields of the CR cover page would be guaranteed to be correct.
- Style errors would be prevented
- The correct specification base text would be used
- Modifying additional clauses or removing affected clauses requires a regeneration of the CR
- Difficult to write and maintain consistent tools based on docx due to high variability in docx file structures
- Some companies do not allow the use of macros.
- This solution only works for the initial version of the CR.
5
CR cover auto-generation
The tool exists online at the time of reserving a TDoc for a CR.
The tool is only available for online use.
6
Restrict editing
The feature is available in current tool used for writing CRs and the specification.
This feature is not available in all docx editors. Furthermore, there is no way to enforce its usage.
7
Training –- (1) correct use of styles
Some tools other than used for processing docx files may not allow delegates full control of the styles.
No training will help in the tendency of word applying styles etc. automatically.
(NOTE 2)
8
Light version of Microsoft Word - light version would include only features used in 3GPP without any additional feature, e.g. removing the possibility of adding new styles, and many other functions.
Removing most of Microsoft Word features should help reduce file sizes, ensure consistent use of styles and formatting, and may make automatic processing of compressed docs files easier.
Microsoft is not likely to create a custom version of Word for 3GPP.
9
EditHelp Consulting from ETSI - This is done before entering change control. After change control secretary review is possible but does not scale well.
Current rules require this
[In principle all authors must use official templates and settings. In practice, no one enforces this]
Forcing adherence to rules leads to slower progress. Those who did so were called CR police - respected, not loved.
This solution relies on accountability by contributors for repeated errors, but this is disrespectful in a professional setting. So this solution is not feasible.
[In principle all authors must use official templates and settings. In practice, no one enforces this]
10
Exhaustive analysis of docx files against 21.801
Issues would be discovered that are currently hidden.
This would have a very large impact on ways of working since authors would need to strictly use MS Word according to rules.
Assuming the proposal is to do this manually, this is hardly a feasible solution.
11
Externalization of APIs and data structures - APIs and data structures could be stored externally to the specification (e.g., Forge repository or external attachment).
- Standard text editors would take on the role of enhancing readability of APIs and data structures by providing colorization, indentation, and syntax highlighting.
- It would make the specs smaller and rendered more quickly.
- It would reduce errors in code/table content that arise from auto-processing feature of MS Word processor.
The specifications would be more difficult to search (considering some specs are currently split into multiple files, the difficulty of searching in multiple files is not new).
Field descriptions and procedures related to the APIs and data structures would be stored separately, requiring more careful checking (unless field descriptions become comments in the code, in which case the problem goes away).
Requires code to be separate from CRs, essentially (unless these are linked). This reduces CR specification cohesiveness.
12
Single representation of APIs and data structures - APIs and data structures could be limited to a single representation.
The need for specifying which version of an API or data structure is authoritative would be eliminated.
Some WGs include additional information, e.g., a tabular form of APIs and data structures and would need to devise a new way of capturing the additional information.
13
[New tool] Automatic syntax checking - Syntax checking
Reference checking, e.g., checking that a datatype of a parameter exists as an intrinsic to the language or as defined elsewhere in the API or data structure specifications.
The volume of CRs with syntax and consistency errors would be reduced.
Many errors cannot be identified without checking across all content associated with the entire target specification, or across multiple specifications.
14
Include the specification number and clause number in references –- When available, include enough information to find the information referenced.
15
Use hyperlinks in references –- manual process
Reader could immediately navigate to a reference without having to search each document.
The specifications are stored as zip files on the 3GPP server and in the 3GPP portal. If links were provided in the specifications, they would be to zip files, which would have to be downloaded, extracted and opened and therefore such solution cannot work offline.
16
[New tool] Script to create, validate, and automate verification of cross-references between specifications
Completeness and accuracy of references can be improved (if a solution is feasible).
If a solution is feasible, it will require extensive parsing of many specifications which may take time and may turn out to be prone to errors. Validation will be complex.
17
Store figure source files - For editable figures, store at least the source file, named in accordance with the figure number, alongside the specification.
- Standalone editors could be used to modify figures
- The figure source would never be lost.
- Because captions and headings are never reused, file naming consistency should be feasible.
- Any time a figure is edited, an extra step needs to be taken to ensure that the figure source file is updated.
- Errors could occur in naming of the source files.
- This disaggregation of content removes one benefit of the use of MS Word, namely that a single file contains all content in a simple way.
18
Store images as vector graphics
Scalable Vector Graphics (SVG) are scalable without distortion and are smaller in file size.
However, they are harder to edit (compared to e.g. MSC-gen or plantUML).
19
Support a limited number of supported formats which work across WGs and platforms
Limited changes to the current way of working. MSC-gen, plantUML and Mermaid are reasonable candidates. Additionally, native Word figures should be considered.
20
Provide comments on CRs in a separate file instead of using bubble comments
Using a separate WORD document for collecting comments is a widely used technique in WGs, and allows responding to comments efficiently
When using a draft FTP folder, comments from multiple delegates may collide in time and separate branches of the same file are created, which are then cumbersome to merge. Delegates have to carefully provide the reference to the clause and line of the spec they are commenting on.
21
Use NWM (or a professional web-based tool) to collect comments
Using NWM (or a commercial web-based tool) for collecting comments is a technique used by some TSGs/WGs.
Using NWM avoids collision of comments, but NWM is not convenient for commenting on equations or figures. Delegates have to carefully provide the reference to the clause and line of the spec they are commenting on.
22
[New tool] Extract text under review and use Git to manage reviews
This would help reviewing text-based large parts of specs where typically a large number of comments are received during the review of a draft TS. Delegates would be able to see spec text and provide a comment directly over that spec text without using another file.
This requires separating (during review time) some parts of the specs which are only text-based for separate commenting, since text-based file formats may not be suitable to parts of specs that contains other types of objects (equations, figures, etc).
23
Use FTP to download latest inputs and upload new inputs
It is based on existing tools.
Simultaneous editing and updating is not possible nor traceable. Coordination is very difficult.
24
Split the CR for review into multiple files –- this can include splitting the ASN.1 from a spec like 38.331 for review.
It is based on existing tools and does help speed up work and reduces some contention.
Other problems are created, as changes to different parts of the spec can diverge. This approach does not scale to large files.
25
Split large specifications into smaller parts
Faster opening
Decreased locality of content, more difficult to maintain, read, browse, search, etc.
26
Open specification and change to draft mode
- Loading and editing times could be reduced.
- Change marks are still visible in draft mode
- It is more difficult to check bubble comments in draft mode
- Some document editing tools have been known to crash prior to being able to enter draft mode.
- Need to ensure correct insertion of figures in WORD so that they are still visible in draft view.
- essentially cancels many of WYSIWYG advantages
27
Produce 3GPP PDF version of the specification after each plenary
- Quicker access to a version of the specification which isn’t impacted by the slowness of some WYSIWYG editors.
- Processing for converting all WORD docs into PDF is done only once for each spec version,
- Cannot be used for producing CRs.
- Only helps spec consumers, not delegates and editors
- Need to ensure that conversion does not lose any information.
- Requires additional storage on FTP server.
28
Make all specs available in HTML
Faster opening, faster search.
Processing for converting all WORD docs into HTML is done only once for each spec version, presumably by MCC.
Cannot be used for producing CRs.
No navigation panel in html.
Need to ensure that conversion does not lose any information.
Requires additional storage on FTP server. Only helps spec consumers, not delegates and editors
29
Mandate the numbering of requirements (PR and CPR) - In some WGs, requirement numbering is done already. Maintenance of numbering is done the normal way - through careful alignment of provisions whenever they are introduced or corrected.
It is possible to refer to requirements without copying the text of the requirement. This reduces the risk of misalignment between specifications.
30
Include WI and meeting number with editor’s notes - For example, Editor’s Note: [FS_AIML-air_core, RAN2#129]
- It would be easier to find the delegate(s) responsible for the editor’s note
- It would be easier to identify stale topics to resolve.
- Slightly more work and introduces meeting-related details into the specification, which isn’t ideal. An alternative would be to find the CR which introduced the Editor’s note.
NOTE 1: Some improvements are essential for CR/meeting handling/discussions and some for improving specification/technical report (TS/TR) editorial quality and usage experience.
NOTE 2: This can hardly be considered a “tools improvement”
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 4.3 Requirements Identification
| Editor's note: corresponds to Objective 1c. The clause may be further divided into different subclauses depending on the discussion.
#
Requirement
Description
Applicable to objective 2
Applicable to objective 3
1
Global availability
There shall be no geographic limitations on availability and usability of tools and formats.
Yes
Yes
2
Cost and licensing
Tools shall be available at reasonable cost.
Ideally, the use of open source and free tools (under reasonable licensing terms) should be prioritized, if possible.
Yes
Yes
3
Security and Availability
Tools shall be secure i.e. robust to manipulation of source code and shall be systematically available (i.e. usable) to avoid 3GPP coming to a halt.
Yes
Yes
4
Cross platform
It shall be possible to view and edit the specifications, including figures, on all major computer platforms (not necessarily including mobile platforms).
Ideally, online variants of these tools should be available (a.k.a. web-GUIs ).
Yes
Yes
5
Simplicity and learning curve
Tools shall be reasonably easy to use and should not cause significant change of the existing working procedures and/or drafting rules.
Yes
Yes
6
Limited number of tools and formats.
Specifications shall only require a limited number of approved formats and recommended tools.
Yes
Yes
7
One reference
It should be possible to produce representations of the specifications in various formats suitable for different situations.
However, at the same time there shall be only one reference. The representation (i.e. reference output) should have consistent appearance to specifications of past generations.
Yes
Yes
8
Fast opening, navigating and editing
Specifications shall be fast (no longer than 30 seconds on a reasonably modern computer even for large and complex specifications) to open.
Furthermore, there shall be no noticeable lag when searching, navigating or editing the specifications.
The tool shall be stable (no crashes) and shall not require splitting large documents into multiple files.
Yes
Yes
9
CR implementation
It shall be possible to quickly and easily (ideally automatically) implement a CR. This applies to both MCC and delegates (e.g. CR/TR rapporteurs).
A tool for automation of CR implementation should allow indicating the exact conflicts and allow specification rapporteurs to review and address such conflicts manually.
Furthermore, it should be possible to automatically detect CR conflicts (e.g. detect if multiple CRs propose changes to text in the same clauses, or the same text, or if a definition is changed for a term that is used in other CRs, etc). In all cases, human verification shall be possible before final approval of the merges of conflict resolutions.
Yes
Yes
10
CR Traceability
Specifications format and tools shall support an easy way for implementors to track introduction of requirements,a new features and corrections to the existing ones.
The specification creation process shall allow recording all changes to the specification, including errors corrected during CR implementation.
Tools used for handling CRs (submission, revisions, agreement, rejection, etc) should allow that all decisions be traceable along with the reasons for decision.
Yes
Yes
11
Feature Traceability
The tools shall allow to document requirements, features and capabilities in a format that can be automatically parsed.
It should be possible (if feasible) to associate a requirement or a feature with the relevant text in all specifications which are related to the feature.
Yes
Yes
12
Cross-referencing and hyperlinking
It shall be possible to cross reference multiple specifications including (sub-)clauses. Such cross referencing shall be easy to navigate e.g. using hyperlinks. A specification shall be able to cross-reference another specification so that the referenced specification text is unambiguous. (NOTE 1)
Tools shall support hyperlinks, including:
- Internal (within the document)
- External (to other documents)
- Ideally, to specific clauses and sections within a document
- Ideally, using relative path (so that the link works anywhere provided the folder structure is maintained)
Yes
Yes
13
Tracking of Editor’s notes
It shall be possible to automatically track Editor’s Notes (EN) addition/removal/resolution (including the origin of the comment such as work item or contributing company), if ENs are used as an issue raising/resolving mechanism.
Yes
Yes
14
References to discussion papers
It shall be possible to reference discussion papers (for background information) in CR cover page (or its equivalent in the new tool/format).
Yes
Yes
15
Automation
Specification format shall enable automation, e.g. to:
- Ensure consistent use of styles
- Extract ASN.1 (if in the new format ASN.1 isn’t stored separately)
- Extract table content for verification, usage and presentation.
- Extract text for verification, usage, and presentation.
- Generate content from other structured data e.g. schemas or JSON data.
- Automated alignment of bands/band configurations between RAN4 specs(e.g. TS 38.101-1/-2/-3) and RAN5 documents (e.g., Excel in PRD21)
- Automated alignment of the completion status of test cases between RAN5 test cases specs (e.g. TS 38.521-1/-2/-3/-4/-5, TS 38.533) and applicability specs (e.g. TS 38.522)
Yes
Yes
16
Specification browsing
It shall be possible to search and navigate within and across specs via both online and offline versions.
It shall be possible to select the exact release and version of a TR or TS to access.
Yes
Yes
17
CR drafting during and in between meetings
It shall be possible to handle the process of drafting a CR involving a large number of contributors who provide a large number of comments and propose a large number of changes. It shall be possible to trace changes and comments to the individual contributors.
CR handling needs to work for normal and electronic meetings, where either only one author can provide revisions or multiple authors from different companies can provide revisions and add comments during the meeting. For the latter scenario, tools shall also support the handling of concurrent revisions by different authors of the same document in order to prevent inconsistent revisions.
(NOTE X7)
Tools need to also work, and before and after meetings for collaborative work between source companies preparing input documents.
(NOTE 2)
Yes
Yes
18
Collaboration on CR drafting between companies
Sharing of draft CRs within and between the source companies for preparing input documents shall be possible.
Yes
Yes
19
Consistent access to CRs and specifications
The tools should allow 3GPP delegates to access CRs and specifications in a similar way as today during pre-meeting, post-meeting and online meeting.
Yes
Yes
20
Visual representation of changes
Tools shall allow visual representation of the changes in a CR and between the original spec and the revision.
The author, i.e., at least the source company, of proposed changes should be visible.
The effects or changes imposed by a CR should be easily readable and navigable such that all the changes can be viewed in the context of the clause affected.
Yes
Yes
21
Supported styles
Tools shall support the following styles:
- Headings –- Heading 1, Heading 2, up to Heading 6
- Hyperlinks –- Internal and external
- Lists (bulleted)
- Lists (hierarchical)
- Lists (numbered) (NOTE 3)
- Tables (simple cell contents; allows different justification {left, center, right})
- Table (column header contents)
- Table of contents
- Text bolding (or equivalent highlighting)
- Text italicization (or equivalent highlighting)
- Text subscript
- Text superscript
- code (in the case code is not stored separately in its native format)
- symbols (non-alpha-numeric characters), non-breaking spaces and hyphens
- Notes
- Editor's Notes
- Table footers
- Table headers
- References
- Equations
Ideally, there should be a way to preclude usage of styles not listed above. In particular, complex tables shall be avoided. Excerpted text from other languages than English (e.g. in references or examples) should also be supported where necessary.
Yes
Yes
22
Supported objects
Tools shall support:
- Figures (e.g. block diagrams, call flow diagrams, images)
- Equations (inline and block).
Yes
Yes
23
Seeing output while editing
The tool shall support the ability to view the content of (part of a specification) in the form in which it will be published (as a specification), including tables and diagrams while and after editing.
No
Yes
24
Offline work
The tool shall support the ability to read and edit specifications and CRs and to verify CRs offline, in particular to allow private editing before submission.
Yes
Yes
25
Meeting decisions and reports (meeting minutes)
Tools shall support tracking decisions of the following: CR, draft CR, pCR, TS, TR with Tdoc numbers in meeting reports.
Yes
Yes
26
Public access to specifications and CRs
Tools shall allow easy access to CRs and Specifications to the larger community, including those who do not actively participate in 3GPP, via both online and offline versions.
The specifications shall be convertible to PDF for publishing.
Yes
Yes
27
Fault tolerance
Tools and working methods should have reasonable fault tolerance against minor human errors. Corner cases should be manageable. The specification creation process should aim to minimize the possibility for human errors.
Yes
No
28
Consistent appearance
New specifications (for 6G) need to have a consistent appearance and quality, similar to previous generations.
Yes
Yes
29
Supported style functions
A delegate, MCC rapporteur shall be able to highlight text, to draw attention to it, even though highlighting is not allowed in the drafting rules and cannot be in an approved CR.
A delegate, MCC rapporteur shall be able to remove all formatting from text.
A delegate, MCC rapporteur shall be able to view non-printing characters (non-breaking spaces, tabs, new lines, page breaks, etc.) if these are added to the content of the CR.
Yes
Yes
30
Comments
It shall be possible to associate a comment with specific provisions (e.g. a paragraph, single word, figure, etc.) of any CR. This comment includes comment text, the identity of the commenter and the time in which the comment was provided.
It shall be possible to remove or 'disassociate' comments with text in a CR.
Yes
Yes
31
CR format
CRs using the new specification format for 6G should support visual emphasis of modified sections, be compatible with file formats acceptable for submission to 3GPP meetings, and allow for seamless transfer of the proposed changes into discussion papers as Text Proposals
Yes
Yes
32
CR cover pages
The tool shall support CR cover page (or its equivalent in the new tool) checking (e.g. no dates in the future, CRs to specifications that don't exist, the other specs affected tick boxes are neither yes nor no, and so on).
The tool shall also support automatic generation of CR cover pages (where possible).
The tool shall also support reviewing, editing and commenting on CR cover pages during CR review process.
Yes
Yes
33
Code
The tool and formats shall support code (e.g. ASN.1).
If code is in the same document as the CR/TS, there should be a means to extract the code portions from the technical specification so that the code can be used as input to machine processing (e.g. an interpreter, compiler, etc.)
Code that is part of a CR/TS should be able to be checked for syntax errors, and compile time errors.
Code that is part of a CR should be able to be checked in combination with other code provided in the specification, to determine if there are redundancies, mismatches, etc.
Yes
Yes
34
Support review of figures
Every change to a figure shall result in a 'change marking' visible, indicating what changed and who made the change.
(NOTE 4)
Yes
Yes
35
Support consistent common configuration
It shall be possible to enforce simple and consistent configuration for users, so that errors arising while creating, editing and cut-n-pasting due to inconsistencies are rare or impossible.
(NOTE 5)
Yes
Yes
36
CRs comprising multiple files
The tools shall support (if needed) CRs comprising multiple files in simple and consistent order (i.e. as separate documents stored in a mandatory way for the associated CR or specification).
Yes
Yes
37
CR database
Changes to CR documents (including headers and content) shall be automatically captured in CR databases to ensure the correct correspondence between an approved and implemented CR and the CR database.
Yes
Yes
38
Support for gathering input on a CR
The tool shall support gathering input on a CR or its content for highly active topics involving many participants, without divergence in the process.
Use of tools to collect comments and feedback shall enable orderly capture of responses, so that the order, source and input from each reviewer is captured without ambiguity or loss. This facility shall scale up to 100s of active reviewers posting 1000s of comments a day.
(NOTE 6)
Yes
Yes
39
Simplicity to follow drafting rules
The tool shall enable editors not to be concerned with styles, but rather with the technical content and its hierarchy in the document.
Yes
Yes
40
Support for visualizing different parts of a document concurrently on the same screen
The tool shall enable visualizing different (incl. disjoint) parts of the same document concurrently on the same screen similar to Split View in MS Word.
Yes
Yes
41
Support for visualizing different documents concurrently on the same screen
The tool should enable visualizing different documents concurrently on the same screen.
Yes
Yes
42
Support for personal scripts
The tool should enable delegate, consumer, MCC/Rapporteur to develop and use their own scripts to manipulate a document locally or together with other documents (similar to MS Office Macros).
Yes
Yes
43
Language proofing
The format shall allow checking a document for errors in spelling, grammar, and punctuation, and ensuring it adheres to the rules of the English language.
Yes
Yes
44
Folder synchronization
The tools shall support an easy, fast and efficient way to synchronize folders
Yes
Yes
NOTE 1: For example, conformance test specifications use heavy cross-referencing between the test spec (e.g. 38.521-1) and associated details in test point analysis (TR 38.905), MU/TT (TR 38.903), UE/UE connection diagrams (TS 38.508-1) which are critical for implementation of the test however difficult to maintain with manual effort.
NOTE 2: The tool should improve upon the process used today.
NOTE 3: Lists can be indented to different levels, e.g. to allow sub-bullets.
NOTE 4: The granularity of the change marking is at least 'the figure has changed.' Greater granularity than that, e.g. highlighting changes in text in a figure, is considered Very Nice To Have.
NOTE 5: This addresses the problem with current use of MS Word where the configuration of the tool is frequently inconsistent and hard to control, leading to poorer CR and specification quality.
NOTE 6: The comments and related information that are gathered can be removed or are not intrinsically part of the CR or specification.
NOTE X7: It is desirable to have only a single sequence of revisions (in that case, different authors would not be able to make changes at all times), but alternative solutions may be considered.
Editor’s note: A “tool” is used as a generic term and need not imply there is a single tool that meets all the mentioned requirements.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5 Proposals for new formats for 3GPP specifications
| Editor's note: corresponds to objective 2.
5.X1 Proposal #X1: OpenDocument
5.X1.1 Description
OpenDocument (ODF) is an open, XML-based file format family for office documents, established as an international standard (ISO/IEC 26300). It's free, transparent, and not controlled by any single vendor. Most importantly, it is a standardized format) which allows to develop tools to automate virtually any task. The ITTF has added ISO/IEC 26300 to its "list of freely available standards"; anyone may download and use this standard free-of-charge under the terms of a click-through license.
The OpenDocument Format (ODF) includes the following main document types:
- Text Documents: .odt (like Microsoft Word's .docx)
- Spreadsheets: .ods (like Microsoft Excel's .xlsx)
- Presentations: .odp (like Microsoft PowerPoint's .pptx)
- Graphics: .odg (for vector graphics)
- Charts: .odc
- Formulas: .odf
- Master Documents: .odm
OpenDocument is an XML-based format with a standardized file structure illustrated below:
├── mimetype # File type identifier
├── META-INF/
│ └── manifest.xml # File listing
├── content.xml # Actual content
├── styles.xml # Formatting styles
├── settings.xml # App settings
├── meta.xml # Metadata
└── Pictures/ # Embedded media
In a properly structured ODF file, content (included in content.xml file) is separate from styles (included in styles.xml).
It is important to note that ODF is a very rich format with feature parity to DOCX, and therefore in theory it is prone to the same misuse that we sometimes see in DOCX standards documents. However, it is possible to agree and more importantly enforce the usage of a limited subset of the ODF features.
The proposal is to use a limited set of ODT styles and features, to strictly ensure through the use of automatic tools compliance with such restricted ODT format and to develop tools to automate common delegate, rapporteur and MCC tasks.
In particular, the following ODT restrictions should be enforced:
- No “automatic styles”, i.e. “content.xml” file should only contain content –- not styles
- “styles.xml” should not be modified, i.e. it should be controlled by MCC
- Only specific embedded media formats should be allowed
- There should be a size limit for a single ODT file, larger files should use “master and subdocument” feature
- Only simple tables should be allowed
- Code (e.g. ASN.1) should be stored in a separate file (this is optional, but useful)
NoteNOTE: whether to use ODG (or some other formats) for diagrams requires further study. Furthermore, if diagram formats other than ODF are selected, further study would be needed on how to include them in ODT documents.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.1 Proposal #1: OpenDocument
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.1.1 Description
| OpenDocument (ODF) is an open, XML-based file format family for office documents, established as an international standard (ISO/IEC 26300). It's free, transparent, and not controlled by any single vendor. Most importantly, it is a standardized format) which allows to develop tools to automate virtually any task. The ITTF has added ISO/IEC 26300 to its "list of freely available standards"; anyone may download and use this standard free-of-charge under the terms of a click-through license.
The OpenDocument Format (ODF) includes the following main document types:
- Text Documents: .odt (like Microsoft Word's .docx)
- Spreadsheets: .ods (like Microsoft Excel's .xlsx)
- Presentations: .odp (like Microsoft PowerPoint's .pptx)
- Graphics: .odg (for vector graphics)
- Charts: .odc
- Formulas: .odf
- Master Documents: .odm
OpenDocument is an XML-based format with a standardized file structure illustrated below:
├── mimetype # File type identifier
├── META-INF/
│ └── manifest.xml # File listing
├── content.xml # Actual content
├── styles.xml # Formatting styles
├── settings.xml # App settings
├── meta.xml # Metadata
└── Pictures/ # Embedded media
In a properly structured ODF file, content (included in content.xml file) is separate from styles (included in styles.xml).
It is important to note that ODF is a very rich format with feature parity to DOCX, and therefore in theory it is prone to the same misuse that we sometimes see in DOCX standards documents. However, it is possible to agree and more importantly enforce the usage of a limited subset of the ODF features.
The proposal is to use a limited set of ODT styles and features, to strictly ensure through the use of automatic tools compliance with such restricted ODT format and to develop tools to automate common delegate, rapporteur and MCC tasks.
In particular, the following ODT restrictions should be enforced:
- No “automatic styles”, i.e. “content.xml” file should only contain content - not styles
- “styles.xml” should not be modified, i.e. it should be controlled by MCC
- Only specific embedded media formats should be allowed
- There should be a size limit for a single ODT file, larger files should use “master and subdocument” feature
- Only simple tables should be allowed
- Code (e.g. ASN.1) should be stored in a separate file (this is optional, but useful)
NOTE: whether to use ODG (or some other formats) for diagrams requires further study. Furthermore, if diagram formats other than ODF are selected, further study would be needed on how to include them in ODT documents.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.2 Proposal #2: Asciidoc
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.2.1 Description
| References below provide extensive descriptions of Asciidoc, which we don’t intent to fully copy here:
- https://asciidoc.org/
- https://asciidoc-wg.eclipse.org/
- https://gitlab.eclipse.org/eclipse/asciidoc-lang
- https://projects.eclipse.org/projects/asciidoc.asciidoc-lang
- https://docs.asciidoctor.org/asciidoc/latest/
References above state that the AsciiDoc Working Group drives the standardization, evolution, and adoption of the AsciiDoc® language through open collaboration and open source, as part of the Eclipse Foundation, which provides individuals and organisations with a mature, scalable, and vendor-neutral environment for open source software collaboration and innovation. The AsciiDoc Language and the accompanying materials are made available under the terms of the Eclipse Public License v 2.0 (EPL-2.0). The user documentation for the AsciiDoc Language, located in the docs/ folder, is made available under the terms of a Creative Commons Attribution 4.0 International License (CC-BY-4.0). Until the first version of the AsciiDoc Language Specification is ratified, AsciiDoc is defined by the Asciidoctor implementation. There is no other official definition of the language.
5.X3 Proposal #3: Markdown
5.X3.1 Description
5.X3.1.1 Introduction of Markdown
Markdown was created by John Gruber in 2004 as an easy-to-read markup language. Popularity of Markdown eventually led to a number of implementations. The original Markdown language had ambiguities that did not get addressed and a group of people has made attempts to standardize the markup language in 2012. This is known as CommonMark and widely accepted as basic specification for Markdown language.
Several different websites have adopted CommonMark but have added their own flavour of the syntax to further extend the Markdown language, which are known as Markdown variants. Some notable Markdown variants are GitHub Flavored Markdown (GFM), MultiMarkdown (MMD), PHP Markdown Extra, R Markdown, GitLab Flavored Markdown (GLFM), and Pandoc variant of Markdown.
Markdown is the language used by Wikipedia to write articles. The language is simple and focused on information rather than on formatting. To that end, the language supports a small number of critical features which easily translate into HTML, the target format for conversion from Markdown. From HTML, a further conversion to PDF is supported for publishing. This section will describe the base features of Markdown, extensions to Markdown, and custom processing which was developed to support specific aspects of 3GPP specifications during the research for this solution.
5.X3.1.2 Benefits of Markdown
As described in the previous section, Markdown separates information from styles. A major pain point with the way specifications are written in 5G is that it is difficult to properly select styles and that time is wasted on non-technical work. Markdown has the potential to solve this challenge to writing the specifications and the p/CRs to the specifications, which is using and maintaining the correct styles. Styles are eventually applied to the HTML file, resulting from the conversion from Markdown, through the use of Cascading Style Sheets (CSS), which can be used to apply fonts, font sizes, font colours, list styles, table header styles, and more. An additional benefit of applying styles in this manner is that it is easier to maintain a consistent appearance throughout the specifications.
A second benefit of Markdown is that the format is purely plaintext and sequential, which is required for use with modern version control tools. A docx file is different in that it is a zip file containing multiple XML files and resources such as images and different filetypes supported by docx. Prior to being extracted or opened, a docx file is a binary file, incompatible with modern version control tools. In order to compare between two version of the same document, it is necessary that the text is human-readable. The sequential nature of the Markdown file makes it simpler to identify changes because they will be localized.
A third benefit is increased performance of editing tools. When editing plaintext Markdown without rendering or preview, text editors work efficiently without crashing. There are many options for text editors, including Microsoft Visual Studio Code, Notepad++, Notepad, Emacs, and many others, depending on the user’s preference. Even with large specifications, the performance is high because fonts and images do not need to be rendered and pagination is unnecessary.
Given the wide adoption of Markdown, there are a variety of methods to preview a rendered version of the Markdown file. One example from Microsoft Visual Studio Code, a free tool, is shown in Figure 5.X3.1.2-1 below.
Figure 5.X3.1.2-1: Markdown preview in Visual Studio Code
The sections that follow describe the base features of Markdown, commonly used extensions to Markdown, and custom 3GPP extensions to Markdown using Pandoc. Then, the high-level process to convert from Markdown to HTML and PDF will be described.
5.X3.1.3 Base features of Markdown
Markdown without extensions supports the following base features, described in Table 5.X3.1.23-1. These features apply to the blocks named “Source” and “Images” in Figure 5.X3.1.12-2. The table names each feature and demonstrates the Markdown and HTML syntax. Because the rendered output of Markdown is represented in an HTML file, an image of the rendered output is provided in the HTML column.
Table 5.X3.1.3-1: Basic features of Markdown
Feature
Markdown
HTML
Notes
Heading
# Heading 1
## Heading 2
…
###### Heading 6
<h1> Heading 1 </h1>
<h2> Heading 2 </h2>
…
<h6> Heading 6 </h6>
Limited to 6 levels. A style specific to each heading level can be applied through CSS, which enables different font sizes for each heading as shown in the example.
Image
<img src=”path” />
Path is the destination, i.e., the image being pointed to, e.g., fig_5.X.1.2-1.svg.
Link
[text](path)
<a href=”path”>text</a>
Text is the text which would be presented as a clickable link, and path is the destination, i.e., the page or resource being linked, e.g., path.html.
List (Ordered)
1. Item 1
2. Item 2
<ol>
<li>Item 1</li>
<li>Item 2</li>
</ol>
List (Unordered)
- Item 1
- Item 2
- Sub Item 2-1
<ul>
<li>Item 1</li>
<li>Item 2</li>
<ul>
<li>Sub Item 2-1</li>
</ul>
</ul>
The bullet style is set by the HTML stylesheet.
Text Decoration (Bold)
**text**
<strong>text</strong>
Example: text
Text Decoration (Italic)
*text*
<em>text</em>
Example: text
Text Decoration (Bold+Italic)
***text***
<strong><em>text</em></strong>
Example: text
5.X3.1.4 Extended features of Markdown
Markdown has been extended to add more features such as equation rendering, superscript and subscript, and grid tables, which enable tables with merged cells. Many popular extensions exist, including Pandoc-flavoured Markdown (https://pandoc.org/MANUAL.html) and GitLab-flavoured Markdown (https://docs.gitlab.com/user/markdown/), but the Pandoc-flavoured Markdown was chosen for explanation of extended features of Markdown due to its general compatibility with other popular versions of Markdown and its use by Pandoc, the tool selected for converting between Markdown and HTML for the example production process of the rendered document. Table 5.X3.1.34-1 describes extended features of Markdown which could be useful in 3GPP specifications.
Table 5.X3.1.4-1: Extended features of Markdown
Feature
Markdown
HTML
Notes
Equation (Block)
C(x,y)=\left \{
\begin{align*}
\begin{pmatrix} x \\ y \end{pmatrix} & x \geq y \\
0 & x < y
\end{align*}
\right.
MathML Conversion (not shown) or Image
Equations are written in the Latex format.
MathML not shown due to complexity and would not be directly entered or edited.
The block equation is entered between $$ and $$ and line breaks in the equation are supported.
Equation (Inline)
that satisfy $k_{l,i}^{(1)} > 0$, $i \neq i_{1,3,l}$, as
MathML Conversion (not shown) or Image
Equations are written in the Latex format.
MathML not shown due to complexity and would not be directly entered or edited.
The inline equation is entered between $ and $ without any line breaks in the equation.
Subscript
base~lower~
base<sub>lower</sub>
Example: baselower
Superscript
base^upper^
base<sup>upper</sup>
Example: baseupper
Table (Simple) – Pipe Table
| Header 1 | Header 2 |
|------------|-------------|
| Cell 1-1 | Cell 2-1 |
| Cell 1-2 | Cell 2-2 |
<table>
<thead>
<tr>
<th>Header 1</th>
<th>Header 2</th>
</tr>
</thead>
<tr>
<td>Cell 1-1</td>
<td>Cell 2-1</td>
</tr>
<tr>
<td>Cell 1-2</td>
<td>Cell 2-2</td>
</tr>
</table>
This type of table supports word-wrapping in cells and supports multi-line cells with manual break tags (<br>). Merged cells are not supported.
Table (Complex) – Grid Table
+----------+----------+
| Header 1 | Header 2 |
+==========+==========+
| Cell 1-1 | Cell 2-1 |
+----------+----------+
| Merged Cell 1 |
+---------------------+
<table>
<thead>
<tr>
<th>Header 1</th>
<th>Header 2</th>
</tr>
</thead>
<tr>
<td>Cell 1-1</td>
<td>Cell 2-1</td>
</tr>
<tr>
<td colspan="2">Merged Cell 1</td>
</tr>
</table>
This type of table supports multi-line cells and merged cells. Cell alignment must be manually maintained using spaces.
A guide to the Latex equation format can be found at https://tug.ctan.org/info/undergradmath/undergradmath.pdf. In the HTML format, either MathML or images in the SVG format can be used to render the equations, and in the PDF format, the image representation is necessary. Additionally, WYSIWYG editors for Latex equations are available as standalone software available offline and as online tools. In either case, an existing equation could be loaded for editing or the tool could be used to create a new equation. The result would then be copied into the Markdown file directly.
5.X3.1.5 3GPP extensions to Markdown with custom processing
To support elements which are specific to 3GPP, some extensions to Markdown have been prototyped. These extensions are written in a language called Lua (https://www.lua.org/), for which an interpreter is built directly into Pandoc, the tool used to convert from Markdown to HTML. The benefit of using Lua over other languages is that the Lua interpreter built into Pandoc has direct access to the structure of the document, making it easy to iterate over custom blocks such as those used to produce the examples of Table 5.X3.1.5-1.
The most straightforward mechanism to perform custom processing in Markdown is to use the code block delimiter with a custom name. Note that in the Markdown version of each feature, the inline code block starts three tildes (~~~) followed by a format name and ends with three tildes (~~~). As part of the command to convert Markdown to HTML, a series of Lua scripts can be entered, with or without parameters, depending on the conversion.
Details on how Lua filters work in Pandoc can be found at https://pandoc.org/lua-filters.html. The basic premise is that the Pandoc iterates over all the elements in a document in its intermediate document representation format, known as the Abstract Syntax Tree (AST). One element which can be found in the AST is the CodeBlock. Lua filters are called on every type of element encountered in the AST, so conditions are used to determine execution.
An example beginning to a Lua function that operates on a CodeBlock is shown below. The function takes a block as input and checks if the type of block is “mscgen”.
function CodeBlock(block)
if block.classes[1] == “mscgen” then
If there is a match, another function is called, which takes the MSC generator source and the chart type as input. The output is the binary representation of the image generated by the tool. The image is given a name, which could come directly from the figure number, and inserted into what Pandoc refers to as its media bag, containing all the images of the document.
pandoc.mediabag.insert(filename, filetype, image)
Then, the caption of the chart is created and attached to the figure.
Lastly, the entire CodeBlock is replaced with a reference to the newly generated image and its name so that when the HTML file is generated, the figure insertion is treated normally as an image insertion.
Table 5.X3.1.5-1: 3GPP extensions to Markdown
Feature
Markdown
HTML
Notes
ASN.1 colorization and indentation
~ ~ ~ asn1
DL-CCCH-MessageType ::= CHOICE {
c1 CHOICE {
rrcReject RRCReject,
rrcSetup RRCSetup,
spare2 NULL,
spare1 NULL
},
messageClassExtension SEQUENCE {}
}
~~~
<div class="asn1-indent-0">DL-CCCH-MessageType ::= <span class="asn1-keyword">CHOICE</span> {</div>
<div class="asn1-indent-1">c1 <span class="asn1-keyword">CHOICE</span> {</div>
<div class="asn1-indent-2">rrcReject RRCReject,</div>
<removed>
Only an excerpt of the HTML is shown because it isn’t human-readable.
Indentation is applied with special classes named asn1-indent#, where # is the level.
Keyword colorization is applied with the class named asn1-keyword.
Comment colorization, not shown here, is applied with the class named asn1-comment.
Band combination tables insertion
~~~ json-table
Table 5.5A.2-2: NR CA configurations and bandwidth combination sets defined for mixed intra-band contiguous and non-contiguous CA;
../contributions/bandCombinations/38.101-1;
INTRABAND_MIXED
~~~
HTML table not shown.
The json-table identifier is used for this code block. The first input is the table caption. The second is the path the band combinations, and the third is a reference to which band combination.
Cover page insertion
The cover page is inserted using a Lua filter which takes the path to an HTML file as input. The HTML file is simply the cover page for the specification.
The cover page is written in HTML because there is more freedom for layout and it is a relatively static page, not benefiting much from auto-generation.
MSC-Generator signalling diagram
~~~ mscgen
{caption="Figure 5.3.2.1-1: Paging"}
hscale=auto;
u: UE;
n: Network;
hspace u - n 200;
n->u: Paging;
~~~
<img src="fig_5.3.2.1-1.svg"/>
The image of the figure is generated using msc-generator and saved as an SVG file as part of the conversion process and then inserted into the HTML using the <img> tag.
Table of contents generation and insertion
The table of contents is inserted using a Lua filter which identifies and tags all headings, extracts their titles, and creates a table of contents in HTML and inserts it between the cover page and the document body.
The CSS stylesheet handles page numbering in the table of contents and in the header of each page.
5.X3.1.6 How to produce a specification using Markdown
Markdown source is not presentable on its own as it is a language intended to be converted to HTML, using a simple syntax and a subset of the features of HTML. Many tools are available for converting Markdown to HTML, but the one which will be used in this solution is called Pandoc, which can be found at https://pandoc.org/. Pandoc is capable of converting between many formats, but we will focus on the conversion from Markdown to HTML.
Figure 5.X3.1.56-1 illustrates the process. The input is the Markdown source file, which has the extension “.md”, and any images and resources, and the output is an HTML file, which has the extension “.html”, and any original images and converted resources.
Figure 5.X3.1.56-1: Process to convert from Markdown to HTML using Pandoc
The input includes markdown source, text resources, image resources, and images. Source is considered native to the base version of Markdown or to the chosen extension to Markdown, e.g., GitHub-flavoured Markdown. Text resources are those which are entered directly into the Markdown file or referenced as files from the Markdown file and converted into a different text representation in the HTML. Example text resources include equations and ASN.1 source. Image resources are those which are entered directly into the Markdown file or referenced as files from the Markdown file and converted into images. Images are simply copied into the HTML representation as they are natively supported.
Figure 5.X3.1.56-2: Detailed process to convert from Markdown to HTML using Pandoc
Each type of element in the Markdown document, whether native or not, requires a stage which converts the element into intermediate resources which are inserted into the HTML or which converts the element directly into HTML.
Figure 5.X3.1.56-3 illustrates one-stage conversion of a simple type, a heading, which is further explained in Section clause 5.X3.1.5. The Markdown formatting is stripped off and HTML formatting is wrapped around the heading title.
Figure 5.X3.1.56-3: Conversion of a simple type from Markdown to HTML
The complex types, which typically result in images or custom formatted text, use a two-stage process. In the additional stage, the complex type is inputted to a conversion stage, the output of which is a resource, e.g., an image, and HTML which inserts the resource into the HTML document, e.g., an image tag which points to an image resource. Figure 5.X3.1.56-4 shows an example of converting a signalling chart written in MSC Generator and inserting it into the resulting HTML document.
Figure 5.X3.1.56-4: Conversion of a complex type, sequence chart, from Markdown to HTML
Another element to discuss is how styles are applied to the HTML document. The most common mechanism by which styles are applied to an HTML file is through the use of cascading stylesheets (CSS), which can be specified inline to the HTML or externally in a CSS file. Stylesheets work similarly to styles in Microsoft Word, except that styles are not individually applied but rather they are applied automatically depending on the type of element.
For example, the following styles were defined for heading text mimicking the current specifications. Note that the first header style has a thin border on the top, “border-top”, a larger font size than the others, 24, and has additional padding on the bottom to make it more prominent. The remaining headers use the default font and only set the size.
h1 {
font-size: 24px;
border-top: 1px solid;
width: 100%;
float:left;
padding-bottom: 3px;
}
h2 { font-size: 21px; }
h3 { font-size: 19px; }
h4 { font-size: 16px; }
h5 { font-size: 15px; }
h6 { font-size: 13px; }
These styles apply a font size to all six heading styles but treats the first heading level specially by including a black line border above the heading and applying more padding below the header than for the others.
The last step to create a publishable specification is to convert the HTML file to a PDF. A program called WeasyPrint (https://weasyprint.org/) is used. WeasyPrint creates converts HTML to a PDF with consideration to the CSS stylesheet provided with the HTML file. In this solution, the “print” view is used to automatically add headers to each page, including the title and page number, and to properly number the table of contents. All internal links are functional in the PDF version.
5.X4 Proposal #X4: Multiple formats for single specification with Markdown as baseline
5.X4.1 Description
In the table below it is described how the various specification elements of a single specification could be stored, i.e. which file format they could be stored, where the main document of the specification is written with Markdown.
It should be noted that some specification elements can be captured in different formats depending on what is to be captured. One such example is tables, e.g. small tables might best be captured inline with the procedural text and hence captured in Markdown, but very large tables might best be captured in for example JSON.
Table 5.X4.1-1: Specification elements of a single specification, files formats and tools.
Specification element
(NOTE 1)
File formats
Tools
Notes
Main document of the specification, including procedural text and similar (formatted text)
Markdown (*.md)
Any text editor such as Notepad++, Visual Studio Code, Vim, Ghostwriter, vscodium, etc.
Tools are mentioned as examples. In principle any text editor could be used to edit markdown files.
Visual Studio Code allows searching over multiple files.
Tables
JSON (*.json) for large tables
Markdown (*.md) within the main document for small tables
Any text editor such as Notepad++, Visual Studio Code, Vim, etc
All the open-source free tools mentioned here have open-source extensions for Markdown and JSON syntax checking and validation.
Sequence diagrams
Text file (.txt) + PNG or JPEG files
Any text editor + PlantUML or MSC Generator
Any text editor for the textual description of the flow chart. PlantUML or MSC generator for generating the corresponding PNG or JPEG file.
ASN.1
Text file (*.asn)
Any text editor such as Notepad++ or Visual Studio Code + optionally ASN.1 syntax checking extension (e.g. ASN.1 by OSS Nokalva Inc. extension for VSCode)
The ASN.1 elements can be distributed in multiple files which then can be referenced/imported in other ASN.1 files.
Equations
LaTeX written within Markdown for formulas within the main document
Images
Any General-Purpose Diagramming Tool File
Any General-Purpose Diagramming Tools
A PNG or JPEG file should be generated from the diagram file. The image in the PNG format can be referenced and displayed from the Markdown file.
NOTE 1: Some elements may appear only in some specifications but not in all specifications.
To summarize the proposal, the above is a list of potential ways to keep various specification elements, i.e. in which file formats they should be kept. The format of the files shall be such that is serves the best the characteristics of the specification element, e.g., Markdown for the procedural text, asn-files for ASN.1, etc.
Regarding tools to write these formats, in many cases a simple text editor could be sufficient, however they could also be edited in something like the 3GPP Forge.
5.X Proposal #X
5.X.1 Description
5.X.2 Evaluation against requirements of section 4.3
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.3 Proposal #3: Markdown
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.3.1 Description
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.3.1.1 Introduction of Markdown
| Markdown was created by John Gruber in 2004 as an easy-to-read markup language. Popularity of Markdown eventually led to a number of implementations. The original Markdown language had ambiguities that did not get addressed and a group of people has made attempts to standardize the markup language in 2012. This is known as CommonMark and widely accepted as basic specification for Markdown language.
Several different websites have adopted CommonMark but have added their own flavour of the syntax to further extend the Markdown language, which are known as Markdown variants. Some notable Markdown variants are GitHub Flavored Markdown (GFM), MultiMarkdown (MMD), PHP Markdown Extra, R Markdown, GitLab Flavored Markdown (GLFM), and Pandoc variant of Markdown.
Markdown is the language used by Wikipedia to write articles. The language is simple and focused on information rather than on formatting. To that end, the language supports a small number of critical features which easily translate into HTML, the target format for conversion from Markdown. From HTML, a further conversion to PDF is supported for publishing. This section will describe the base features of Markdown, extensions to Markdown, and custom processing which was developed to support specific aspects of 3GPP specifications during the research for this solution.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.3.1.2 Benefits of Markdown
| As described in the previous section, Markdown separates information from styles. A major pain point with the way specifications are written in 5G is that it is difficult to properly select styles and that time is wasted on non-technical work. Markdown has the potential to solve this challenge to writing the specifications and the p/CRs to the specifications, which is using and maintaining the correct styles. Styles are eventually applied to the HTML file, resulting from the conversion from Markdown, through the use of Cascading Style Sheets (CSS), which can be used to apply fonts, font sizes, font colours, list styles, table header styles, and more. An additional benefit of applying styles in this manner is that it is easier to maintain a consistent appearance throughout the specifications.
A second benefit of Markdown is that the format is purely plaintext and sequential, which is required for use with modern version control tools. A docx file is different in that it is a zip file containing multiple XML files and resources such as images and different filetypes supported by docx. Prior to being extracted or opened, a docx file is a binary file, incompatible with modern version control tools. In order to compare between two version of the same document, it is necessary that the text is human-readable. The sequential nature of the Markdown file makes it simpler to identify changes because they will be localized.
A third benefit is increased performance of editing tools. When editing plaintext Markdown without rendering or preview, text editors work efficiently without crashing. There are many options for text editors, including Microsoft Visual Studio Code, Notepad++, Notepad, Emacs, and many others, depending on the user’s preference. Even with large specifications, the performance is high because fonts and images do not need to be rendered and pagination is unnecessary.
Given the wide adoption of Markdown, there are a variety of methods to preview a rendered version of the Markdown file. One example from Microsoft Visual Studio Code, a free tool, is shown in Figure 5.3.1.2-1 below.
Figure 5.3.1.2-1: Markdown preview in Visual Studio Code
The sections that follow describe the base features of Markdown, commonly used extensions to Markdown, and custom 3GPP extensions to Markdown using Pandoc. Then, the high-level process to convert from Markdown to HTML and PDF will be described.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.3.1.3 Base features of Markdown
| Markdown without extensions supports the following base features, described in Table 5.3.1.3-1. These features apply to the blocks named “Source” and “Images” in Figure 5.3.1.2-2. The table names each feature and demonstrates the Markdown and HTML syntax. Because the rendered output of Markdown is represented in an HTML file, an image of the rendered output is provided in the HTML column.
Table 5.3.1.3-1: Basic features of Markdown
Feature
Markdown
HTML
Notes
Heading
# Heading 1
## Heading 2
…
###### Heading 6
<h1> Heading 1 </h1>
<h2> Heading 2 </h2>
…
<h6> Heading 6 </h6>
Limited to 6 levels. A style specific to each heading level can be applied through CSS, which enables different font sizes for each heading as shown in the example.
Image
<img src=”path” />
Path is the destination, i.e., the image being pointed to, e.g., fig_5.X.1.2-1.svg.
Link
[text](path)
<a href=”path”>text</a>
Text is the text which would be presented as a clickable link, and path is the destination, i.e., the page or resource being linked, e.g., path.html.
List (Ordered)
1. Item 1
2. Item 2
<ol>
<li>Item 1</li>
<li>Item 2</li>
</ol>
List (Unordered)
- Item 1
- Item 2
- Sub Item 2-1
<ul>
<li>Item 1</li>
<li>Item 2</li>
<ul>
<li>Sub Item 2-1</li>
</ul>
</ul>
The bullet style is set by the HTML stylesheet.
Text Decoration (Bold)
**text**
<strong>text</strong>
Example: text
Text Decoration (Italic)
*text*
<em>text</em>
Example: text
Text Decoration (Bold+Italic)
***text***
<strong><em>text</em></strong>
Example: text
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.3.1.4 Extended features of Markdown
| Markdown has been extended to add more features such as equation rendering, superscript and subscript, and grid tables, which enable tables with merged cells. Many popular extensions exist, including Pandoc-flavoured Markdown (https://pandoc.org/MANUAL.html) and GitLab-flavoured Markdown (https://docs.gitlab.com/user/markdown/), but the Pandoc-flavoured Markdown was chosen for explanation of extended features of Markdown due to its general compatibility with other popular versions of Markdown and its use by Pandoc, the tool selected for converting between Markdown and HTML for the example production process of the rendered document. Table 5.3.1.4-1 describes extended features of Markdown which could be useful in 3GPP specifications.
Table 5.3.1.4-1: Extended features of Markdown
Feature
Markdown
HTML
Notes
Equation (Block)
C(x,y)=\left \{
\begin{align*}
\begin{pmatrix} x \\ y \end{pmatrix} & x \geq y \\
0 & x < y
\end{align*}
\right.
MathML Conversion (not shown) or Image
Equations are written in the Latex format.
MathML not shown due to complexity and would not be directly entered or edited.
The block equation is entered between $$ and $$ and line breaks in the equation are supported.
Equation (Inline)
that satisfy $k_{l,i}^{(1)} > 0$, $i \neq i_{1,3,l}$, as
MathML Conversion (not shown) or Image
Equations are written in the Latex format.
MathML not shown due to complexity and would not be directly entered or edited.
The inline equation is entered between $ and $ without any line breaks in the equation.
Subscript
base~lower~
base<sub>lower</sub>
Example: baselower
Superscript
base^upper^
base<sup>upper</sup>
Example: baseupper
Table (Simple) – Pipe Table
| Header 1 | Header 2 |
|------------|-------------|
| Cell 1-1 | Cell 2-1 |
| Cell 1-2 | Cell 2-2 |
<table>
<thead>
<tr>
<th>Header 1</th>
<th>Header 2</th>
</tr>
</thead>
<tr>
<td>Cell 1-1</td>
<td>Cell 2-1</td>
</tr>
<tr>
<td>Cell 1-2</td>
<td>Cell 2-2</td>
</tr>
</table>
This type of table supports word-wrapping in cells and supports multi-line cells with manual break tags (<br>). Merged cells are not supported.
Table (Complex) – Grid Table
+----------+----------+
| Header 1 | Header 2 |
+==========+==========+
| Cell 1-1 | Cell 2-1 |
+----------+----------+
| Merged Cell 1 |
+---------------------+
<table>
<thead>
<tr>
<th>Header 1</th>
<th>Header 2</th>
</tr>
</thead>
<tr>
<td>Cell 1-1</td>
<td>Cell 2-1</td>
</tr>
<tr>
<td colspan="2">Merged Cell 1</td>
</tr>
</table>
This type of table supports multi-line cells and merged cells. Cell alignment must be manually maintained using spaces.
A guide to the Latex equation format can be found at https://tug.ctan.org/info/undergradmath/undergradmath.pdf. In the HTML format, either MathML or images in the SVG format can be used to render the equations, and in the PDF format, the image representation is necessary. Additionally, WYSIWYG editors for Latex equations are available as standalone software available offline and as online tools. In either case, an existing equation could be loaded for editing or the tool could be used to create a new equation. The result would then be copied into the Markdown file directly.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.3.1.5 3GPP extensions to Markdown with custom processing
| To support elements which are specific to 3GPP, some extensions to Markdown have been prototyped. These extensions are written in a language called Lua (https://www.lua.org/), for which an interpreter is built directly into Pandoc, the tool used to convert from Markdown to HTML. The benefit of using Lua over other languages is that the Lua interpreter built into Pandoc has direct access to the structure of the document, making it easy to iterate over custom blocks such as those used to produce the examples of Table 5.3.1.5-1.
The most straightforward mechanism to perform custom processing in Markdown is to use the code block delimiter with a custom name. Note that in the Markdown version of each feature, the inline code block starts three tildes (~~~) followed by a format name and ends with three tildes (~~~). As part of the command to convert Markdown to HTML, a series of Lua scripts can be entered, with or without parameters, depending on the conversion.
Details on how Lua filters work in Pandoc can be found at https://pandoc.org/lua-filters.html. The basic premise is that the Pandoc iterates over all the elements in a document in its intermediate document representation format, known as the Abstract Syntax Tree (AST). One element which can be found in the AST is the CodeBlock. Lua filters are called on every type of element encountered in the AST, so conditions are used to determine execution.
An example beginning to a Lua function that operates on a CodeBlock is shown below. The function takes a block as input and checks if the type of block is “mscgen”.
function CodeBlock(block)
if block.classes[1] == “mscgen” then
If there is a match, another function is called, which takes the MSC generator source and the chart type as input. The output is the binary representation of the image generated by the tool. The image is given a name, which could come directly from the figure number, and inserted into what Pandoc refers to as its media bag, containing all the images of the document.
pandoc.mediabag.insert(filename, filetype, image)
Then, the caption of the chart is created and attached to the figure.
Lastly, the entire CodeBlock is replaced with a reference to the newly generated image and its name so that when the HTML file is generated, the figure insertion is treated normally as an image insertion.
Table 5.3.1.5-1: 3GPP extensions to Markdown
Feature
Markdown
HTML
Notes
ASN.1 colorization and indentation
~ ~ ~ asn1
DL-CCCH-MessageType ::= CHOICE {
c1 CHOICE {
rrcReject RRCReject,
rrcSetup RRCSetup,
spare2 NULL,
spare1 NULL
},
messageClassExtension SEQUENCE {}
}
~~~
<div class="asn1-indent-0">DL-CCCH-MessageType ::= <span class="asn1-keyword">CHOICE</span> {</div>
<div class="asn1-indent-1">c1 <span class="asn1-keyword">CHOICE</span> {</div>
<div class="asn1-indent-2">rrcReject RRCReject,</div>
<removed>
Only an excerpt of the HTML is shown because it isn’t human-readable.
Indentation is applied with special classes named asn1-indent#, where # is the level.
Keyword colorization is applied with the class named asn1-keyword.
Comment colorization, not shown here, is applied with the class named asn1-comment.
Band combination tables insertion
~~~ json-table
Table 5.5A.2-2: NR CA configurations and bandwidth combination sets defined for mixed intra-band contiguous and non-contiguous CA;
../contributions/bandCombinations/38.101-1;
INTRABAND_MIXED
~~~
HTML table not shown.
The json-table identifier is used for this code block. The first input is the table caption. The second is the path the band combinations, and the third is a reference to which band combination.
Cover page insertion
The cover page is inserted using a Lua filter which takes the path to an HTML file as input. The HTML file is simply the cover page for the specification.
The cover page is written in HTML because there is more freedom for layout and it is a relatively static page, not benefiting much from auto-generation.
MSC-Generator signalling diagram
~~~ mscgen
{caption="Figure 5.3.2.1-1: Paging"}
hscale=auto;
u: UE;
n: Network;
hspace u - n 200;
n->u: Paging;
~~~
<img src="fig_5.3.2.1-1.svg"/>
The image of the figure is generated using msc-generator and saved as an SVG file as part of the conversion process and then inserted into the HTML using the <img> tag.
Table of contents generation and insertion
The table of contents is inserted using a Lua filter which identifies and tags all headings, extracts their titles, and creates a table of contents in HTML and inserts it between the cover page and the document body.
The CSS stylesheet handles page numbering in the table of contents and in the header of each page.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.3.1.6 How to produce a specification using Markdown
| Markdown source is not presentable on its own as it is a language intended to be converted to HTML, using a simple syntax and a subset of the features of HTML. Many tools are available for converting Markdown to HTML, but the one which will be used in this solution is called Pandoc, which can be found at https://pandoc.org/. Pandoc is capable of converting between many formats, but we will focus on the conversion from Markdown to HTML.
Figure 5.3.1.6-1 illustrates the process. The input is the Markdown source file, which has the extension “.md”, and any images and resources, and the output is an HTML file, which has the extension “.html”, and any original images and converted resources.
Figure 5.3.1.6-1: Process to convert from Markdown to HTML using Pandoc
The input includes markdown source, text resources, image resources, and images. Source is considered native to the base version of Markdown or to the chosen extension to Markdown, e.g., GitHub-flavoured Markdown. Text resources are those which are entered directly into the Markdown file or referenced as files from the Markdown file and converted into a different text representation in the HTML. Example text resources include equations and ASN.1 source. Image resources are those which are entered directly into the Markdown file or referenced as files from the Markdown file and converted into images. Images are simply copied into the HTML representation as they are natively supported.
Figure 5.3.1.6-2: Detailed process to convert from Markdown to HTML using Pandoc
Each type of element in the Markdown document, whether native or not, requires a stage which converts the element into intermediate resources which are inserted into the HTML or which converts the element directly into HTML.
Figure 5.3.1.6-3 illustrates one-stage conversion of a simple type, a heading, which is further explained in clause 5.3.1.5. The Markdown formatting is stripped off and HTML formatting is wrapped around the heading title.
Figure 5.3.1.6-3: Conversion of a simple type from Markdown to HTML
The complex types, which typically result in images or custom formatted text, use a two-stage process. In the additional stage, the complex type is inputted to a conversion stage, the output of which is a resource, e.g., an image, and HTML which inserts the resource into the HTML document, e.g., an image tag which points to an image resource. Figure 5.3.1.6-4 shows an example of converting a signalling chart written in MSC Generator and inserting it into the resulting HTML document.
Figure 5.3.1.6-4: Conversion of a complex type, sequence chart, from Markdown to HTML
Another element to discuss is how styles are applied to the HTML document. The most common mechanism by which styles are applied to an HTML file is through the use of cascading stylesheets (CSS), which can be specified inline to the HTML or externally in a CSS file. Stylesheets work similarly to styles in Microsoft Word, except that styles are not individually applied but rather they are applied automatically depending on the type of element.
For example, the following styles were defined for heading text mimicking the current specifications. Note that the first header style has a thin border on the top, “border-top”, a larger font size than the others, 24, and has additional padding on the bottom to make it more prominent. The remaining headers use the default font and only set the size.
h1 {
font-size: 24px;
border-top: 1px solid;
width: 100%;
float:left;
padding-bottom: 3px;
}
h2 { font-size: 21px; }
h3 { font-size: 19px; }
h4 { font-size: 16px; }
h5 { font-size: 15px; }
h6 { font-size: 13px; }
These styles apply a font size to all six heading styles but treats the first heading level specially by including a black line border above the heading and applying more padding below the header than for the others.
The last step to create a publishable specification is to convert the HTML file to a PDF. A program called WeasyPrint (https://weasyprint.org/) is used. WeasyPrint creates converts HTML to a PDF with consideration to the CSS stylesheet provided with the HTML file. In this solution, the “print” view is used to automatically add headers to each page, including the title and page number, and to properly number the table of contents. All internal links are functional in the PDF version.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.4 Proposal #4: Multiple formats for single specification with Markdown as baseline
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 5.4.1 Description
| In the table below it is described how the various specification elements of a single specification could be stored, i.e. which file format they could be stored, where the main document of the specification is written with Markdown.
It should be noted that some specification elements can be captured in different formats depending on what is to be captured. One such example is tables, e.g. small tables might best be captured inline with the procedural text and hence captured in Markdown, but very large tables might best be captured in for example JSON.
Table 5.4.1-1: Specification elements of a single specification, files formats and tools.
Specification element
(NOTE 1)
File formats
Tools
Notes
Main document of the specification, including procedural text and similar (formatted text)
Markdown (*.md)
Any text editor such as Notepad++, Visual Studio Code, Vim, Ghostwriter, vscodium, etc.
Tools are mentioned as examples. In principle any text editor could be used to edit markdown files.
Visual Studio Code allows searching over multiple files.
Tables
JSON (*.json) for large tables
Markdown (*.md) within the main document for small tables
Any text editor such as Notepad++, Visual Studio Code, Vim, etc
All the open-source free tools mentioned here have open-source extensions for Markdown and JSON syntax checking and validation.
Sequence diagrams
Text file (.txt) + PNG or JPEG files
Any text editor + PlantUML or MSC Generator
Any text editor for the textual description of the flow chart. PlantUML or MSC generator for generating the corresponding PNG or JPEG file.
ASN.1
Text file (*.asn)
Any text editor such as Notepad++ or Visual Studio Code + optionally ASN.1 syntax checking extension (e.g. ASN.1 by OSS Nokalva Inc. extension for VSCode)
The ASN.1 elements can be distributed in multiple files which then can be referenced/imported in other ASN.1 files.
Equations
LaTeX written within Markdown for formulas within the main document
Images
Any General-Purpose Diagramming Tool File
Any General-Purpose Diagramming Tools
A PNG or JPEG file should be generated from the diagram file. The image in the PNG format can be referenced and displayed from the Markdown file.
NOTE 1: Some elements may appear only in some specifications but not in all specifications.
To summarize the proposal, the above is a list of potential ways to keep various specification elements, i.e. in which file formats they should be kept. The format of the files shall be such that is serves the best the characteristics of the specification element, e.g., Markdown for the procedural text, asn-files for ASN.1, etc.
Regarding tools to write these formats, in many cases a simple text editor could be sufficient, however they could also be edited in something like the 3GPP Forge.
5.X Proposal #X
5.X.1 Description
5.X.2 Evaluation against requirements of section 4.3
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6 Proposals for Tools and Ways of Working
| Editor's note: corresponds to objective 3.
6.X1 Proposal #X1: tools and ways of working for OpenDocument
6.X1.1 Description
6.X1.1.1 Description of tools
For editing ODT documents, LibreOffice is a natural choice, however it is by no means the only option. Here is a short and not exhaustive list of such tools with short summaries of their strengths:
- LibreOffice Writer: This is arguably the most popular and comprehensive ODT editor. It's free, open-source, and cross-platform.
- Google Docs: While primarily a web-based editor, Google Docs offers good support for opening, editing, and saving ODT files.
- Microsoft Word: Microsoft Word has some support for ODT, but the compatibility isn't always perfect (e.g. Track Changes aren’t supported, i.e. when you save the Word document in .odt format, all changes are accepted), and some formatting may be lost or altered. It's generally better to use a dedicated ODT editor if you're working extensively with the format.
- Calligra Words: Part of the Calligra Suite, this is a free and open-source option, particularly popular in the Linux community.
As for automation, there are libraries available for OpenDocument automation, with the two most promising ones being:
- LibreOffice API available for Java and C++
- odfpy for Python
Furthermore, since OpenDocument is a standardized XML-based format, one can always use XML manipulation libraries (which are many and some of them are extremely powerful) to literally do anything with OpenDocument files.
LibreOffice has a certification program and provides a list of certified developers who can be commissioned to develop:
- New LibreOffice features
- Tools for/based-on LibreOffice
- Various automation scripts
With this, various automation tools can be developed for delegates, rapporteurs and MCC. It is important to note that it is not only possible to develop tools for ODT, but since it is an open-source tool, it is possible to enhance LibreOffice itself to support 3GPP-specific functionality.
6.X2 Proposal #X2 Git for Version Control
6.X2.1 Description
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.1 Proposal #1: tools and ways of working for OpenDocument
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.1.1 Description
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.1.1.1 Description of tools
| For editing ODT documents, LibreOffice is a natural choice, however it is by no means the only option. Here is a short and not exhaustive list of such tools with short summaries of their strengths:
- LibreOffice Writer: This is arguably the most popular and comprehensive ODT editor. It's free, open-source, and cross-platform.
- Google Docs: While primarily a web-based editor, Google Docs offers good support for opening, editing, and saving ODT files.
- Microsoft Word: Microsoft Word has some support for ODT, but the compatibility isn't always perfect (e.g. Track Changes aren’t supported, i.e. when you save the Word document in .odt format, all changes are accepted), and some formatting may be lost or altered. It's generally better to use a dedicated ODT editor if you're working extensively with the format.
- Calligra Words: Part of the Calligra Suite, this is a free and open-source option, particularly popular in the Linux community.
As for automation, there are libraries available for OpenDocument automation, with the two most promising ones being:
- LibreOffice API available for Java and C++
- odfpy for Python
Furthermore, since OpenDocument is a standardized XML-based format, one can always use XML manipulation libraries (which are many and some of them are extremely powerful) to literally do anything with OpenDocument files.
LibreOffice has a certification program and provides a list of certified developers who can be commissioned to develop:
- New LibreOffice features
- Tools for/based-on LibreOffice
- Various automation scripts
With this, various automation tools can be developed for delegates, rapporteurs and MCC. It is important to note that it is not only possible to develop tools for ODT, but since it is an open-source tool, it is possible to enhance LibreOffice itself to support 3GPP-specific functionality.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2 Proposal #2 Git for Version Control
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1 Description
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1.0 Overview
| Git is an open-source distributed version control system, which tracks changes to files and enables collaboration.
Distributed means that every user can download and update a full copy of the repository, including files and their history locally (not just the current files, but also the full change history, also known as a commit graph). Changes are made and recorded locally and later synchronized with other copies using network operations (push, pull, fetch).
We can distinguish four areas in git workflow (see Figure 6.X2.1.0-1):
- Remote repository - A copy of the project hosted on a server (e.g., 3GPP Forge, GitLab, or an SSH/git server) that acts as a shared central repository for collaborators to push to and fetch from. It stores the full history and interaction with it is done over the network.
- Local repository - The complete Git repository on your machine (.git directory) containing the full commit history and references. The user can commit, branch, and inspect history offline.
- Working directory (working tree) - The user edits the checked-out files locally, derived from a commit in the local repository. Changes in this area are unrecorded until staged and committed
- Staging area (index) - A temporary area where user place selected changes (with git add command) to build the next commit, letting user control exactly which modifications become part of that commit.
Figure 6.X2.1.0.-1: Git workflow areas and basic procedures
Editor's Note: It is FFS how the databases described in this clause relate to the existing databases (tdoc database, CR database, and the meeting report. What are the impact on the processes that interact with these existing databases.
6.X2.1.1 Description of tools
6.X2.1.1.1 Git commit
The Git commit command records a snapshot of the project’s staged changes, capturing the state of the codebase at a particular point of time. Each commit consists of following elements:
- Metadata - Includes author, committer, message, timestamps, and a unique identifier called a SHA hash.
- Commit Message - Describes what the commit changes and why. This is crucial for understanding project history.
- Parent Reference - Points to the previous commit(s), allowing Git to track project history as a directed acyclic graph.
The Git commit message can be standardized using a pre-defined template. It can be achieved with Conventional Commits, which is a specification for writing consistent and meaningful commit messages in Git. Its goal is to make project history easier to read, automate changelogs, and enable semantic versioning.
Commit message can be composed of following elements (Figure 6.X2.1.1.1-1):
- Type - Nature of the change (feat, fix, docs, style, refactor, test, chore)
- Scope - Area of the codebase affected
- Subject - Short summary of the change
- Body - Detailed explanation, motivation, or context
- Footer - References to issues, breaking changes, or metadata
Figure 6.X2.1.1.1-1 Example commit message structure
6.X2.1.1.2 Git branching
Git branching is essential for managing projects efficiently in collaborative and feature-driven development workflows. Key aspects of branching include:
- Creating independent lines of development
- Isolate changes and work on new features, bug fixes, or experiments without affecting the main codebase
- Enable collaboration by allowing multiple users to work on different branches
- Maintain stability in the main branch
Git merge feature is used to combines commits from one branch into another. Any conflicts that occur during merge are resolved manually and recorded in the resulting commit. In the example of Figure 6.X2.1.1.2-1, we start with the main branch, which contained v18.1.0. A branch called v18.2.0 was created to aggregate accepted changes to v18.1.0. Two CRs are shown in the diagram: CR-123 and CR-456. Both CRs were created from the same initial version, corresponding to v18.1.0 and the changes imposed by each CR were written independently from one another, enabling parallel work. Each CR went through a few revisions, i.e., CR-456:1 and CR-456:2 prior to being finally accepted and merged into the v18.2.0 branch. Once both CRs were merged, the v18.2.0 branch was merged into the main branch, becoming the latest version of the specification.
Figure 6.X2.1.1.2-1: Example git branching and merging
6.X2.1.1.3 Git history
Git history provides detailed information about every single change introduced by commits, including:
- Commit Details: Includes commit hashes, messages, authors, dates, and timestamps.
- Changes to Files: Tracks what changes were made to specific files over time.
- Branch Contributions: Identifies changes introduced by specific branches.
- Author Contributions: Shows who made specific changes and when.
- Line-Level History: Provides details on the last modification for each line in a file.
- Time-Based Changes: Filters commits based on specific timeframes (e.g., last two days).
- Searchable Commit Messages: Allows searching for commits related to particular functionality or keywords.
Git history can be visualized using git commit graph (Figure 6.X2.1.1.3-1), which is the directed acyclic graph (DAG) that represents commits and their parent relationships in a Git repository. Visualizations called "git graphs" expose the repository history and topology. Key information a git graph provides:
- Commits as nodes: each node is a commit (hash), with author, date, and commit message.
- Parent/child edges: arrows/lines show parent relationships.
- Branch and tag labels: which commits are pointed to by refs (branch names, tags).
- Branching and merging structure: where branches diverged and were merged back.
- Topology vs time: order can be topological (ancestry) or chronological; visualization usually combines both.
- Reachability and history context: which commits are reachable from which branches.
Figure 6.X2.1.1.3-1: Example git graph visualization in Gitlab (source docs.gitlab.com)
Git CLI commands used to browse repository history:
- git log - Displays the commit history for current branch.
- git diff - Compare changes between different states of a repository
- git blame - Displays line-by-line history of a file, showing the author, date, and commit hash for each line.
- git show - Displays detailed information about a specific commit, including the commit message and diff of changes.
6.X2.1.1.4 Git GUI tools
Git itself is a CLI (Command Line Interface) based tool, but it is also integrated in many existing GUI (Graphical User Interface) tools. Because Git repositories are decentralized, it can be completely up to user preference which tools to use. Some examples of Git tools include:
- Built-in GUIs:
- git-gui — Simple official Tcl/Tk GUI shipped with Git for staging, committing, and basic history browsing.
- gitk — Official repository history browser/visualizer that ships with Git for commit graph inspection.
- Windows Git GUI (installed with Git for Windows) — Lightweight GUI wrapper for common Git tasks on Windows.
- Server / hosted tools:
- GitLab — Full DevOps platform with repo hosting, CI/CD, issue tracking, merge requests and web-based file/PR UI. This is the same platform used by 3GPP Forge and ETSI Forge.
- GitHub — Widely used hosted Git service with pull requests, code review, Actions CI, and web-based file and diff editors.
- IDE integrations
- Visual Studio Code — Built-in Source Control view and many Git extensions for staging, branching, diffs and merges.
- JetBrains IDEs (IntelliJ, PyCharm) — Integrated VCS tools with GUI for commits, branches, history, and conflict resolution.
- Visual Studio — Integrated Git client and GitHub/GitLab extensions for full repo workflows inside the IDE.
6.X2.1.2 Description of procedures
6.X2.1.2.1 Git procedures description
Basic git commands for creating and saving changes (see Figure 6.X2.1.0-1):
- git clone – Create a full local copy of a remote repository, it contains both file and changes history.
- git fetch – Download changes history (commits) and references from a remote repository into local repository without changing working files.
- git pull – Fetch changes from remote repository and merge them into working copy.
- git add – Stage changes (new / modified / deleted files) to prepare them for a commit to local repository.
- git commit – Record staged changes as a new local snapshot in the repository history.
- git push – Send local changes (commits) to a remote repository, so others can access them.
- git branch – Create, list, or switch between independent lines of development (isolated commit histories).
6.X2.1.2.2 Mapping Git procedures to Change Request processes
We can compare the typical current CR procedure (Figure 6.X2.1.2.2-1) to a potential future CR procedure with Git (Figure 6.X2.1.2.2-2), relating each current step to the Git equivalent in the new procedure. The mapping provided is not meant to imply a solution, but rather to relate the Git flow to our current 3GPP flow. For instance, the second to last step in Figure 6.X2.1.2.2-2 suggests that a TDoc representing the CR will be automatically generated and provided as a docx file which can be submitted. That is only one possibility.
For the purpose of 3GPP, additional fields can be added to the commit message, such as work item description (WID) or study item description (SID) code.
- Steps with solid green borders are nearly equivalent steps.
- Steps with a dashed orange border are modified from the original procedure.
- Steps with a squiggly black border are unique to each procedure.
Figure 6.X2.1.2.2-1: Current typical CR procedure
Figure 66.12.1.2.2-2: One potential new CR procedure with Git
Editor’s Note: The feasibility of automatically generating a Word document with Track Changes from Git commits is for further study along with the required tool(s).
6.X2.2 Evaluation against requirements of section 4.3
Editor's Note: Evaluation is FFS.
6.X Proposal #X
6.X.1 Description
6.X.1.1 Description of tools
6.X.1.2 Description of procedures
6.X.2 Evaluation against requirements of section 4.3
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1.1 Description of tools
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1.1.1 Git commit
| The Git commit command records a snapshot of the project’s staged changes, capturing the state of the codebase at a particular point of time. Each commit consists of following elements:
- Metadata - Includes author, committer, message, timestamps, and a unique identifier called a SHA hash.
- Commit Message - Describes what the commit changes and why. This is crucial for understanding project history.
- Parent Reference - Points to the previous commit(s), allowing Git to track project history as a directed acyclic graph.
The Git commit message can be standardized using a pre-defined template. It can be achieved with Conventional Commits, which is a specification for writing consistent and meaningful commit messages in Git. Its goal is to make project history easier to read, automate changelogs, and enable semantic versioning.
Commit message can be composed of following elements (Figure 6.2.1.1.1-1):
- Type - Nature of the change (feat, fix, docs, style, refactor, test, chore)
- Scope - Area of the codebase affected
- Subject - Short summary of the change
- Body - Detailed explanation, motivation, or context
- Footer - References to issues, breaking changes, or metadata
Figure 6.2.1.1.1-1 Example commit message structure
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1.1.2 Git branching
| Git branching is essential for managing projects efficiently in collaborative and feature-driven development workflows. Key aspects of branching include:
- Creating independent lines of development
- Isolate changes and work on new features, bug fixes, or experiments without affecting the main codebase
- Enable collaboration by allowing multiple users to work on different branches
- Maintain stability in the main branch
Git merge feature is used to combines commits from one branch into another. Any conflicts that occur during merge are resolved manually and recorded in the resulting commit. In the example of Figure 6.2.1.1.2-1, we start with the main branch, which contained v18.1.0. A branch called v18.2.0 was created to aggregate accepted changes to v18.1.0. Two CRs are shown in the diagram: CR-123 and CR-456. Both CRs were created from the same initial version, corresponding to v18.1.0 and the changes imposed by each CR were written independently from one another, enabling parallel work. Each CR went through a few revisions, i.e., CR-456:1 and CR-456:2 prior to being finally accepted and merged into the v18.2.0 branch. Once both CRs were merged, the v18.2.0 branch was merged into the main branch, becoming the latest version of the specification.
Figure 6.2.1.1.2-1: Example git branching and merging
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1.1.3 Git history
| Git history provides detailed information about every single change introduced by commits, including:
- Commit Details: Includes commit hashes, messages, authors, dates, and timestamps.
- Changes to Files: Tracks what changes were made to specific files over time.
- Branch Contributions: Identifies changes introduced by specific branches.
- Author Contributions: Shows who made specific changes and when.
- Line-Level History: Provides details on the last modification for each line in a file.
- Time-Based Changes: Filters commits based on specific timeframes (e.g., last two days).
- Searchable Commit Messages: Allows searching for commits related to particular functionality or keywords.
Git history can be visualized using git commit graph (Figure 6.2.1.1.3-1), which is the directed acyclic graph (DAG) that represents commits and their parent relationships in a Git repository. Visualizations called "git graphs" expose the repository history and topology. Key information a git graph provides:
- Commits as nodes: each node is a commit (hash), with author, date, and commit message.
- Parent/child edges: arrows/lines show parent relationships.
- Branch and tag labels: which commits are pointed to by refs (branch names, tags).
- Branching and merging structure: where branches diverged and were merged back.
- Topology vs time: order can be topological (ancestry) or chronological; visualization usually combines both.
- Reachability and history context: which commits are reachable from which branches.
Figure 6.2.1.1.3-1: Example git graph visualization in Gitlab (source docs.gitlab.com)
Git CLI commands used to browse repository history:
- git log - Displays the commit history for current branch.
- git diff - Compare changes between different states of a repository
- git blame - Displays line-by-line history of a file, showing the author, date, and commit hash for each line.
- git show - Displays detailed information about a specific commit, including the commit message and diff of changes.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1.1.4 Git GUI tools
| Git itself is a CLI (Command Line Interface) based tool, but it is also integrated in many existing GUI (Graphical User Interface) tools. Because Git repositories are decentralized, it can be completely up to user preference which tools to use. Some examples of Git tools include:
- Built-in GUIs:
- git-gui — Simple official Tcl/Tk GUI shipped with Git for staging, committing, and basic history browsing.
- gitk — Official repository history browser/visualizer that ships with Git for commit graph inspection.
- Windows Git GUI (installed with Git for Windows) — Lightweight GUI wrapper for common Git tasks on Windows.
- Server / hosted tools:
- GitLab — Full DevOps platform with repo hosting, CI/CD, issue tracking, merge requests and web-based file/PR UI. This is the same platform used by 3GPP Forge and ETSI Forge.
- GitHub — Widely used hosted Git service with pull requests, code review, Actions CI, and web-based file and diff editors.
- IDE integrations
- Visual Studio Code — Built-in Source Control view and many Git extensions for staging, branching, diffs and merges.
- JetBrains IDEs (IntelliJ, PyCharm) — Integrated VCS tools with GUI for commits, branches, history, and conflict resolution.
- Visual Studio — Integrated Git client and GitHub/GitLab extensions for full repo workflows inside the IDE.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1.2 Description of procedures
| |
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1.2.1 Git procedures description
| Basic git commands for creating and saving changes (see Figure 6.2.1.0-1):
- git clone – Create a full local copy of a remote repository, it contains both file and changes history.
- git fetch – Download changes history (commits) and references from a remote repository into local repository without changing working files.
- git pull – Fetch changes from remote repository and merge them into working copy.
- git add – Stage changes (new / modified / deleted files) to prepare them for a commit to local repository.
- git commit – Record staged changes as a new local snapshot in the repository history.
- git push – Send local changes (commits) to a remote repository, so others can access them.
- git branch – Create, list, or switch between independent lines of development (isolated commit histories).
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.1.2.2 Mapping Git procedures to Change Request processes
| We can compare the typical current CR procedure (Figure 6.2.1.2.2-1) to a potential future CR procedure with Git (Figure 6.2.1.2.2-2), relating each current step to the Git equivalent in the new procedure. The mapping provided is not meant to imply a solution, but rather to relate the Git flow to our current 3GPP flow. For instance, the second to last step in Figure 6.2.1.2.2-2 suggests that a TDoc representing the CR will be automatically generated and provided as a docx file which can be submitted. That is only one possibility.
For the purpose of 3GPP, additional fields can be added to the commit message, such as work item description (WID) or study item description (SID) code.
- Steps with solid green borders are nearly equivalent steps.
- Steps with a dashed orange border are modified from the original procedure.
- Steps with a squiggly black border are unique to each procedure.
Figure 6.2.1.2.2-1: Current typical CR procedure
Figure6.2.1.2.2-2: One potential new CR procedure with Git
Editor’s Note: The feasibility of automatically generating a Word document with Track Changes from Git commits is for further study along with the required tool(s).
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 6.2.2 Evaluation against requirements of section 4.3
| Editor's Note: Evaluation is FFS.
6.X Proposal #X
6.X.1 Description
6.X.1.1 Description of tools
6.X.1.2 Description of procedures
6.X.2 Evaluation against requirements of section 4.3
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 7 Overall evaluation
| Editor's note: Overall evaluation of combined proposals from sections 5 and 6, including trials.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 8 Recommendations
| Editor's note: Final recommendations
Annex A:
3GPP Stakeholder Survey on CR Tools
As part of the effort to develop tools ''New Working Methods'' during the years 2015-2022, a 3GPP stakeholder survey was performed in 2022 [3]. The goal of this survey was to provide clear input on requirements and expectations with respect to specification development with CRs. A summary of results of the survey are presented here.
NOTE: For those interested, the reference [3] includes also the data set used for the assessment summarized in the present document. There were also many interesting comments provided by responders to the survey which are omitted in this synopsis.
The interpretation of the survey is merely intended to be well-founded input to the present document.
The terms 'must have' or 'low priority' were used in the analysis of the survey. These terms are informative only.
A.1 Methodology
3GPP stakeholders were surveyed, with input specifically solicited from delegates, implementers, secretaries, OP delegates, 3GPP leaders (working group and TSG chairs, vice chairs).
Table A.1-1: Survey Response
Category
Responses
% of total
Delegate
556
91.3
Rapporteur of Specification Editor
144
23.7
Leader (Chair, Vice Chair)
17
2.8
Secretary or MCC
7
1.2
OP transposer
2
0.3
Moderator / Feature Leads
58
9.5
Engineer (who implements specifications in products or services)
39
6.4
Other (please specify)
17
2.8
The categories were not exclusive. A single responder could check both 'Delegate' and 'Rapporteur' for example. The categories were useful to select for specific evaluation for analysis and comparison.
All questions were of the form "I need…" and could be answered with results shown below. Only results that were not 'non-applicable' were counted.
0 [non-applicable];
1 [Not useful, don't do this];
2 [I don't need this, others might];
3 [Useful, would be helpful];
4 [I need this from time to time];
5 [I need this very often, a 'must have']
In order to assess the results for each question, the following was used to categorize the results:
Table A.1-2: Survey Response Interpretation
Interpretation
Positive Responses (3, 4 or 5)
Must have % rating "5"
µ and σ
Must Have
> 0.82
> 45% responses
µ + σ > 5.25
High Priority
0.75 > x > 0.82
40 – 45% responses
µ + σ > 4.8
Medium Priority
Low priority
< 65%
< 30% responses
µ - σ < 2
Strong indication of low priority
< 55%
< 20% responses
µ + σ < 1.5
The range of experience of responders varied, less than 3 years (newcomers) 20.5%, 3-6 years (since 5G) 24.8%, 7-14 years (since 4G) 29.6%, >14 years (since 3G) 25.1%
A.2 Major Findings
In the tables below, the needs are listed in their relative levels of needs. The survey question numbers (in the # column) remain so these items can be references in the rest of the TR. Please refer to the survey report [3].
Table A.2-1: Must have needs
#
Topic
Need
3.1
General
I need to review, edit and otherwise access CRs off-line, that is, with no access to the Internet.
3.5
General
I rely on 'recovery features' so that I do not lose work if there is an interruption or failure of some kind (computer, software, network, etc.) while editing or creating CRs.
3.6
General
I rely on tools to indicate incorrect spelling in documents I edit or compose.
3.8
General
I use 'advanced search' capabilities for search and replace (match case, find whole words, use wildcards, search 'up' vs. 'down', etc.)
3.9
General
I rely on 'what you see is what you get' presentation of content on pages as I edit or create content in CRs.
3.14
General
I need to be able to use the tool to open multiple windows (or to split windows) to different parts of the same document.
3.16
General
I need the tool to capture every change made in a CR such that the change identifies who made the change and when it was made (similar to Microsoft Word Revision Marks).
3.14
General
I need to be able to use the tool to open multiple windows (or to split windows) to different parts of the same document.
3.18
General
I need the tool to capture every change made in a CR such that the change identifies who made the change and when it was made (similar to Microsoft Word Revision Marks).
3.19
General
I need to be able to add comments to any content in a CR including text, figures, header fields, etc. These comments need to capture my name and the time they were made.
3.20
General
I need to be able to delete comments from CRs.
3.21
General
I need to be able to respond to comments so that the response is kept in the context of the comment.
3.22
General
I need to be able to see comments and responses to comments, so that I see who provided the comment and when.
3.24
General
I need the tool to enable me to reject any change. [NOTE 1]
8.1
Tables
I need to adjust the column and row widths, as the automatic width and height settings are insufficient.
8.5
Tables
I merge cells.
8.6
Tables
I split cells.
8.7
Tables
I adjust cell alignment (e.g. upper left, centered, lower right, etc.).
10.1
Text
I need to identify the appropriate clause number when inserting a new clause into a specification under change control.
10.2
Text
I highlight text.
10.3
Text
I enter or modify subscripts and superscripts in text.
10.4
Text
I insert symbols (non-alphanumeric characters).
10.9
Text
I create and modify multi-level bulleted lists in CRs.
13.1
Equations
I need to have a 'what you see is what you get' style of equation editor, such as the Open Math ML editor.
17.3
Code
I need code to be displayed in a form optimized for readability of the given language, e.g. appropriate indentations, colors, etc.)
17.6
Code
I need the tool to identify every character that is proposed to be changed by a CR (similar to word revision marks) rather than just identifying entire lines that are proposed to be changed.
23.1
CR check
I need to check the CR specification information (is the specification number correct, the latest version used for the corresponding release, the CR number correct (assigned to this CR) and that the work item code (WIC) exists in the release corresponding to this CR (or allowed for a mirror CR).
23.4
CR check
I need to check whether the source, reason for change, summary of change and consequences if not approved sections are filled in. I need to identify multiple sources and authors in the source field.
23.5
CR check
I need to check whether the category is filled in and is an allowed value.
23.6
CR check
I need to check whether the CR header is 'clean' (no revision marks or comments) since these are not allowed in the revision of CRs that can be agreed in WG or approved in TSG.
23.7
CR check
I need to check whether the sections affected field is filled in and that this corresponds exactly to the sections included in the set of changes that the CR contains.
23.8
CR check
I need to check whether the 'Other specs affected' tick boxes are checked, and if they are, that they correspond to existing specifications.
23.9
CR check
I need to check that the CR revision number is correct.
23.11
CR check
I need to check that a CR is based on the most recent version of the specification, for the specification and release targeted by the CR.
27.1
CR impl.
I need to be able to identify a set of CRs and a source specification to which the changes will be applied. As a result I need to produce two versions of the target specification - one 'clean' and the other 'revision marked.'
NOTE 1: 'Accepting changes' to the source specification in a CR is not allowed since a CR must show all changes to the unmodified specification text. The only way to accept changes in a CR is for TSG to approve the CR and the change to be implemented to create a new version of a specification.
Table A.2-2: High priority needs
#
Topic
Need
3.13
General
My company / organization needs to create, modify and otherwise develop CRs (and specifications) autonomously, so that the data is only stored and accessible by my company / organization.
3.23
General
I need to be able to search for comments from specific authors (see all comments by a particular commenter).
5.1
Figures
I adjust the formatting of images (png, jpg, etc.) in CRs (e.g. size, centering).
5.3
Figures
I create editable figures within the tool (using figure drawing mechanisms to drop elements, resize, type text, etc.)
5.4
Figures
I create (and edit) editable figures externally from the tool and import or paste them in.
8.4
Tables
I adjust the indentation of cells (above, below, left, right) surrounding the text content of the cells.
8.8
Tables
I adjust text direction (e.g. to write vertically instead of horizontally).
8.9
Tables
I shade rows or columns (e.g. with light gray).
8.10
Tables
I need to add equations to cells in tables.
8.12
Tables
I need to add figures to cells in tables.
10.5
Text
I insert non-printing characters (e.g. non-breaking spaces) in text.
10.6
Text
I remove all formatting of text.
10.7
Text
I view non-printing characters (including non-breaking spaces, carriage return, tabs, etc.)
13.3
Equations
I need the tool to capture every change made in an equation such that the change identifies who made the change and when it was made. [NOTE 1]
17.1
Code
I need code to be embedded within the same document as the rest of the Technical Specification to which the code is associated. Note: this question asks how important it is, in your opinion, that code is embedded in the specification itself rather than provided some other way, e.g. by reference or as a component in the CR or specification 'zip file', etc.
20.1
MSC
I need MSC to be embedded within the same document as the rest of the Technical Specification to which the code is associated. [NOTE 2]
20.2
MSC
I need the machine-readable format of MSCs to be stored in a CR or specification such that it can be modified by others.
23.2
CR check
I need to check that the CR title does not change after it is assigned.
23.3
CR check
I need to check whether the date is in the proper format.
25.1
CR check
I need to check CRs for compliance to TR 21.801 drafting rules, e.g. use of styles, non-breaking spaces, avoiding use of tabs, avoiding 'hanging paragraphs,' etc.
25.2
CR check
I need to check that CRs use the latest CR Form (template).
25.4
CR check
I need to identify all abbreviations in a CR that are neither defined in the specification, nor in TR 21.905, nor in the cited 3GPP specifications in the reference section.
25.7
CR check
I need to check whether a set of CRs clash with each other where the CRs target the same version of the same release of a specification. Note: A CR clash is when more than one CR proposes changes to the same text.
25.8
CR check
I need to check if a CR includes all changes compared with the previous specification version and against a previous rev of the same CR. Note: This could happen if a change were made without 'track changes' being activated. This question also asks whether it is difficult to identify 'new' changes if all changes are marked the same way.
27.2
CR impl.
I need to check if there are clashes between the set of CRs applied to the same source specification. If this is the case I need to create a list of all the clashes to resolve in order to create a new version of the specification correctly.
27.3
CR impl.
I need to determine if there are any 'warnings' or 'errors' present in all the input CRs. If so, I need to list all these warnings and errors. The errors must all be corrected in order to create a new version of the specification correctly.
NOTE 1: This requirement would go beyond Revision Marks in Microsoft Word that merely show that an equation has changed and not what in a figure has changed.
NOTE 2: This question asks how important it is, in your opinion, that code is embedded in the specification itself as it is (as MSC) as opposed to using an external tool to generate a figure (e.g. PNG file) and including that in the specification.
Table A.2-3: Medium priority (missing some 'high priority' criteria)
#
Topic
Need
3.4
General
I need a tool that allows importing of documents and content created in Microsoft Word. [NOTE 1]
3.10
General
I need a way to compare two user-specified versions of the same specification, (e.g. TS 38.331 v17.2.0 vs v17.0.0) to identify the differences. I also need to be able to filter this 'difference' presentation, so that I can select a specific Work Item Code, (e.g. only show changes due to NR_MBS-Core). [NOTE 1]
3.12
General
I rely on keyboard shortcuts for efficiency (beyond cut/copy/paste/undo). [NOTE 2]
3.17
General
I need for the tool to enforce the marking of any change in a CR compared to the latest version of the targeted release of the source specification. [NOTE 2][NOTE 3]
5.5
Figures
I create and import non-editable images (png, jpg, etc.) instead of editable figures when I cannot create the figure I require.
5.6
Figures
I need images that are not editable in the tool to be stored as an editable source file in the CR or specification so that the image can be modified by others.
5.7
Figures
I need the tool to capture every change made in a figure such that the change identifies who made the change and when it was made.
8.2
Tables
I need to apply formatting to tables beyond those provided in 21.801 styles, and beyond basic text formatting (e.g. bold). Examples of 'going beyond 21.801' are shading of rows.
8.11
Figures
I need to add figures to cells in tables.
10.8
Text
I adjust paragraph attributes that are not in the 3GPP template (e.g. alignment, indentation, spacing before and after lines). [NOTE 2]
13.2
Equations
I need to have a mark-up language based editor for equations, such as latex.
17.2
Code
If embedded within the same document as the rest of the technical specification, I need the tool to provide automatic extraction of the code portions in the technical specification. [NOTE 2]
17.4
Code
I need the tool used for creating and editing code to perform syntax checking. [NOTE 2]
17.5
Code
I need the tool used for creating and editing code to perform compilation checking of the code. [NOTE 2]
17.7
Code
I need the tool to identify conflicts (i.e. that would result in syntax or compilation errors) with code in other CRs and the specification that the CR targets. [NOTE 2]
23.10
CR check
I need to warn me if there are no 'change affects' tick boxes ticked as this is a 'warning': though in some special cases this is intended, lack of tick boxes ticked is generally an error. [NOTE 2]
23.12
CR check
I need the tool to help create mirror CRs, especially so that the header page is set up properly. [NOTE 2]
25.3
CR check
I need to check references: does each reference added have text in the specification that refers to it? Do all references added to specification text have corresponding references? [NOTE 2]
25.6
CR check
I need to search change marked documents for all changes by a specific source 'individual member' (associated with the marked revision). [NOTE 2]
27.4
CR impl.
I need to be able to use the CR and specification tool to apply pseudo-CRs as changes to a source specification. [NOTE 4]
27.5
CR impl.
I need to create a next version of the target specification with as much assistance from automated implementation as possible. [NOTE 5]
27.6
CR impl.
I need to create an interim version of the target specification that reflects the specification status after the first of more than one working group meeting in a single quarter. [NOTE 6]
NOTE 1: Though many were positive about this, there was a high σ, resulting in a strong trailing edge. Skepticism?
NOTE 2: There was a large variation in responses.
NOTE 3: This is not true today. Change marking is manually controlled by the user. It is thus possible to improperly create an incorrect CR with changes that are not marked.
NOTE 4: pseudo-CRs are currently informally structured documents. Please take into account in answering this question that in order to support implementation of pseudo-CRs in a tool, it may be necessary that pseudo-CRs documents become more formal in their structure. For example, it may be necessary to define and fill in a pseudo-CR header page.
NOTE 5: This was a 'must have' when rapporteurs and secretariats are selected as the responding group. In general responses, only 72% responded positively. The criteria for unambiguous 'high priority' is 75% or higher response of 3, 4 or 5.
NOTE 6: Though interim versions of specifications have no official status since CRs are only sent to TSG for approval at the end of a quarter, some delegates may benefit from the ability to view the cumulative result of all agreed CRs (and even postponed CRs) to a given specification.
In all rows of Table A.2-3, there was less than 40% 'must have' responses.
Table A.2-4: Low and very low priority
#
Topic
Need
3.2
General
I need a tool which does not require any additional software to be installed on my PC beyond those tools used today.
3.3
General
I use in-company or other non-3GPP tools which require access to the CR database and/or the full set of CR files.
3.7
General
I use different layouts of CRs while I work on them, including print layout and 'web' layout (without pages or fixed width).
3.11
General
I rely on help facilities.
3.15
General
I need to collect all source files together with the CR, for example, the source file used to create a figure, equation, etc. Note that even though it is not required today in all 3GPP groups to collect all source files for figures, equations, etc. with the CR, in future this could become a requirement.
5.2
Figures
I embellish the presentation of images in CRs (e.g. adding a border, drop shadow, other 'effects.')
25.5
CR check
I need to search change marked documents for all changes after a given date, e.g. after CEST yesterday.
A.3 Specific Requirements for Rapporteurs and Secretaries
In a follow up study, Q25 and Q27 were reviewed specifically in the responses of secretaries and rapporteurs.
Q25: Do you have any other needs with respect to filling in or checking the header sheets of CRs?
Q27: Do you have any other needs with respect to checking the correctness of CRs?
Table A.3-1: Must Have for Rapporteurs and Secretaries
#
Topic
Need
25.1
CR check
I need to check CRs for compliance to TR 21.801 drafting rules, e.g. use of styles, non-breaking spaces, avoiding use of tabs, avoiding 'hanging paragraphs,' etc.
25.2
CR check
I need to check that CRs use the latest CR Form (template).
25.3
CR check
I need to check references: does each reference added have text in the specification that refers to it? Do all references added to specification text have corresponding references?
25.7
CR check
I need to check whether a set of CRs clash with each other where the CRs target the same version of the same release of a specification. Note: A CR clash is when more than one CR proposes changes to the same text.
25.8
CR check
I need to check if a CR includes all changes compared with the previous specification version and against a previous rev of the same CR. [NOTE 1]
27.1
CR impl.
I need to be able to identify a set of CRs and a source specification to which the changes will be applied. As a result I need to produce two versions of the target specification - one 'clean' and the other 'revision marked.'
27.2
CR check
I need to check if there are clashes between the set of CRs applied to the same source specification. If this is the case, I need to create a list of all the clashes to resolve in order to create a new version of the specification correctly.
27.3
CR check
I need to determine if there are any 'warnings' or 'errors' present in all the input CRs. If so, I need to list all these warnings and errors. The errors must all be corrected in order to create a new version of the specification correctly.
27.5
CR impl.
I need to create a next version of the target specification with as much assistance from automated implementation as possible.
NOTE 1: This could happen if a change were made without 'track changes' being activated. This question also asks whether it is difficult to identify 'new' changes if all changes are marked the same way.
Interestingly, secretaries agreed that the following is very important, but some rapporteurs disagreed:
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 25.4 I need to identify all abbreviations in a CR that are neither defined in the specification, nor in 21.905, nor in the cited 3GPP specifications in the reference section.
| Some secretaries found this useful, but most found the feature unimportant:
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 25.5 I need to search change marked documents for all changes after a given date, e.g. after CEST yesterday.
| While most rapporteurs agreed this was important, there was disagreement with secretaries. One even commented: "don't do this!"
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 27.6 I need to create an interim version of the target specification that reflects the specification status after the first of more than one working group meeting in a single quarter.
| NOTE 1: Though interim versions of specifications have no official status since CRs are only sent to TSG for approval at the end of a quarter, some delegates may benefit from the ability to view the cumulative result of all agreed CRs (and even postponed CRs) to a given specification
While some rapporteurs found this important, there is disagreement. Secretaries do not see this as important.
|
c56330969404dda9ba1e88a5a188ba6a | 21.802 | 27.4 I need to be able to use the CR and specification tool to apply pseudo-CRs as changes to a source specification.
| NOTE 2: Pseudo-CRs (pCRs) are currently informally structured documents. Please take into account in answering this question that in order support implementation of pseudo-CRs in a tool, it may be necessary that pseudo-CRs documents become more formal in their structure. For example, it may be necessary to define and fill in a pseudo-CR header page.
This topic could have been underdeveloped in the survey. It seems very strange that one would automate CR quality improvement and implementation, but not support pCRs. During the early phase of development of specifications, pCRs are used to incorporate most of the content that will remain forever, before change control begins.
Annex B:
Survey of specification formats, tools, and CR processes in use by 3GPP WGs in 2025
In 2025, 3GPP WGs are using Word for writing specifications and for working on CRs/pCRs in meetings. Additional tools (e.g. Visio, Msc-generator, PlantUML) are used for crafting objects that are then embedded in Word. For some WGs, such as RAN1 and RAN2, specifications are published only using Word with embedded objects. In order to address specific needs of certain WGs, some WGs use additional file formats for writing annexes or attachments to the specifications (e.g. YAML file/codec codes).
Table B-1 below summarizes the various tools in use as of 2025 in 3GPP WGs. When only Word is mentioned, it is implied that built-in tools for handling equations, tables, and for drawing figures are also commonly being used. The table indicates when parts of the specifications are also stored on 3GPP Forge (https://forge.3gpp.org), while when not indicated the storage of the specifications is only on 3gpp.org/ftp/Specs also accessible via the 3GPP portal 3GU (https://portal.3gpp.org/).
Table B-1 – Survey of formats and tools in use as of 2025 by 3GPP WGs for specifications and CRs
Specification formats/tools
Formats/tools/processes used for CRs
CT1
Word (Visio and MSC-GEN for figures). XML files are included as annex in the Word file of a TS. OpenAPI files are included as .yaml files (Notepad++) in the ZIP file of a TS, and the OpenAPI text is also copied into the Word doc of that TS in annexes. A YAML file is also stored as a fixed branch in Git on 3GPP Forge. These 3 versions must be identical.
3GPP Forge for OpenAPI YAML files: OpenAPI descriptions are extracted from the annex of the 3GPP Technical Specifications and made available as stand-alone YAML files, identified by a file name composed of the API name prefixed by the TS number of the specification containing the OpenAPI description. All these files are then stored in a common repository managed by Gitlab on the 3GPP Forge for testing.
YAML text parser (Notepad++) to generate YAML file (note that new swagger version does not support saving of YAML file and cross checking).
OpenAPI YAML syntax checker (Swagger tool)
XML syntax checker/validator.
CDDL and JSON syntax checker/validator.
Word + Visio, Excel
regex101: used to build, test, and debug regex, to check regular expressions online.
CRs are submitted in 3GU, stored on 3gpp.org/ftp, and after the meeting agreed CRs are tested using Git in 3GPP forge:
1. A company submits a CR for an OpenAPI using Word in 3GU, showing track changes to the YAML text copied from the Word annex of a TS with OpenAPI. The company submitting the CR shall check and correct errors early, and list the impacted API(s) on the cover page. The list can be generated using 3GPP Forge.
2. CT1 discusses CRs for that OpenAPI during the meeting. The CRs agreed during the CT1 meeting don’t include a separate .yaml file but just a Word file.
3. After the CT1 meeting, the TS rapporteur merges all agreed CRs for that OpenAPI into a .yaml file (using NotePad++), as part of drafting the TS update.
4. The TS rapporteur checks for syntax errors in Swagger, and provides the checked .yaml file to 3GPP Forge and on FTP draft folder (and also use Github e.g. to detect issues with APIs referring to each other). If CR implementation errors are found the TS Rapporteur proposes a correction and asks Source companies if they agree and asks for a revision to next meeting/plenary.
5. Delegates review the comments from rapporteur, .yaml files and draft TS for correctness and provide feedback on the email reflector.
6. For CRs which are agreed by CT1 and need a correction, the source companies provide a company revision to next plenary with an indication corrected due to errors found during pre-implementation and checking.
7. Once the CRs (including Word docs and .yaml files) are approved in plenary, TS rapporteur provide final version of TS and .yaml files. MCC is doing a final check (e.g. running their Macros) and TS is uploaded to ftp/Specs and the Git branch is fixed and cannot be updated anymore by delegates/rapporteurs. MCC is creating a new draft branch for next plenary for testing.
Similar is valid for correcting or changing a specification’s text, with the difference that Git is not used for text other than .yaml files.
CT3
See CT1
See CT1
CT4
See CT1
See CT1
CT6
Word (Visio for figures)
Word + Visio
CRs are submitted in 3GU, stored on 3gpp.org/ftp
RAN1
Word, Excel (in some cases for TRs)
Excel (included as attachment in a single zip file for some TRs). The formula tool built in Excel is used for calculating e.g. link budgets.
Word
CRs are submitted in 3GU, stored on 3gpp.org/ftp
In RAN1 (and some other RAN WGs such as RAN2), TS rapporteurs are tasked at certain stages with providing a CR for their responsible TS which merges together all or many of the changes agreed during a RAN1 meeting relating to a given release, and these editor’s CRs are reviewed by delegates before submission to RAN plenary. TS rapporteurs are not tasked with providing a draft TS merging all approved CRs for their TS. This is done by the MCC officer (RAN1 secretary) after RAN plenary for all TSs under RAN1 responsibility. Draft TSs are provided for review by delegates after which the new version of the TSs is published.
RAN2
Word (Visio and MSC-GEN for figures)
ASN.1 syntax checker (not included in spec)
Word (Visio and MSC-GEN for figures)
CRs are submitted in 3GU, stored on 3gpp.org/ftp
RAN3
Word (Visio and MSC-GEN for figures)
ASN.1 syntax checker (not included in spec)
Word (Visio and MSC-GEN for figures)
CRs are submitted in 3GU, stored on 3gpp.org/ftp
RAN4
Word (Visio for figures), Excel (in some cases)
At least one TR (37.941) includes multiple Excel spreadsheets in separate files in the same zip file
Word (Visio for figures), Excel
CRs are submitted in 3GU, stored on 3gpp.org/ftp
RAN4 use separate tool for the CA/DC band combinations requests (Excel so far; database under construction)
RAN5
Word, Excel, Visio
Excel and Visio (included as attachment in a single zip file, and implemented as part of TR 38.903/38.905). The formula tool built-in Excel is used for calculating e.g. uncertainty values.
Machine processable files specified in TTCN-3 language (.ttcn) are provided as attachments in the zip file of a TS, and are not embedded in the Word doc of a TS. Several TTCN-3 compilers are used for syntax checking the TTCN-3 files.
Word, Excel, Visio
CRs are submitted in 3GU, stored on 3gpp.org/ftp
SA1
Word
Word
CRs are submitted in 3GU, stored on 3gpp.org/ftp
SA2
Word, Visio
Word, Visio
CRs are submitted in 3GU, stored on 3gpp.org/ftp
SA3
Word
Machine deliverable parts (.asn, .xsd) are provided as attachments in the zip file of a TS, and are not embedded in the Word doc of a TS.
Word
CRs are submitted in 3GU, stored on 3gpp.org/ftp
SA3-LI SWG:
- Word + Visio
- 3GPP Forge for ASN.1, following these instructions: https://forge.3gpp.org/rep/sa3/li/-/wikis/How-To/Create-a-CR
A summary of the process used with 3GPP Forge by SA3-LI is provided below:
Changes to 3GPP specifications still have to go through the 3GPP change control procedure, even if the changes are held on the Forge. A CR can refer to the Forge for any changes to the machine deliverable parts, rather than writing them out in a change-marked Word document.
SA3LI puts each CR and each plenary meeting in its own branch. A CR entered as a branch in 3GPP Forge requires to first obtain a CR number from the 3GPP Portal, and to finally be submitted to a WG meeting with a proper CR form. A CR branch follows the branching convention and a name of the form cr/{deliverable/{CR number}, and it is placed in the branch for the plenary meeting that might eventually approve the CR. Revisions of a CR are possible during a WG meeting, and the corresponding commits must be updated along with increasing the CR revision.
One CR branch can include one or more commits, each with a commit hash, which is a unique and durable identifier of the changes in the Forge. This hash (or the URL associated with the commit hash) is to be copied in the "Comments" section of the CR, along with the merge request number.
- 3GPP Forge for storing Visio diagrams and their revisions, following these instructions:
https://forge.3gpp.org/rep/sa3/li_diagrams
Visio diagrams are embedded in the specification Word file. 3GPP Forge is used only as a repository for Visio diagrams that can be downloaded for editing. There is no preview for this type of file within 3GPP Forge. A naming convention is defined allowing for referencing each Visio diagram to its specification and specification release and version.
SA4
Word (Visio, PowerPoint and draw.io for figures, and Msc-generator for UML sequence diagrams). Word macros are used to extract a candidate list of abbreviations from the text, and to support formatting of the TR/TS deliverable.
3GPP Forge for stage 3 OpenAPI YAML and XML Schema Definitions. For some deliverables, the copy on 3GPP Forge is normative; for others it is only an informative copy and the normative API definition is specified in an annex to the TS.
Reference implementations of codecs are developed collaboratively in a WG-specific project area on 3GPP Forge, but the normative version is made available as an attachment to the published TS.
Audio test sequences are published on the 3GPP FTP server.
Video conformance bitstreams and reference sequences are stored externally to 3GPP.
c.f. further details as described for CT1.
Word (Visio, PowerPoint and draw.io for figures, and Msc-generator for UML sequence diagrams).
CRs are submitted in 3GU, stored on 3gpp.org/ftp.
Stage 3 OpenAPI YAML changes are prototyped in a WG-specific project area on 3GPP Forge and manually committed to the 5G_APIs repository following TSG approval.
SA5
Word (PlantUML for figures)
3GPP Forge for stage 3 OpenAPI - c.f. further details as described for CT1
Word (PlantUML for figures)
CRs are submitted in 3GU, stored on 3gpp.org/ftp
3GPP Forge for stage 3 OpenAPI, XSD, and YANG data models. SA5 YANG data models and APIs are validated by an automated pipeline that runs for every push or merge-request event. This pipeline is composed of two stages, validation and generation. Generation stage runs an automated Word CR text generation for the corresponding merge-request.
The generated Word CR text is a changed marked word document that includes all changes made by the associated merge-request. Each modified file (YANG model, OpenAPI or XSD) will be included as a change in the Word CR text. This can be included in the Word Change Request document. The Word CR text can be downloaded from the merge-request webpage or the pipeline-page as described above for the detailed log output files.
SA6
Word
Word
CRs are submitted in 3GU, stored on 3gpp.org/ftp
In addition, MCC provides a number of file templates that are to be used by delegates when drafting CRs, specifications and other document types that are prepared in Word format. These templates are regularly updated and available in meeting-specific folders such as https://www.3gpp.org/ftp/tsg_ran/TSG_RAN/TSGR_108/Templates. Some templates are also available at https://www.3gpp.org/ftp/Information/All_Templates.
MCC also provides a number of tools (Macros) to help with using 3GPP Styles, available at the same link as above. "Unofficial" macros are also used by some groups for specific purposes e.g. ASN.1 review in RAN2
For specific purposes, such as for the collection of evaluation results in an excel worksheet, other templates may be provided by the rapporteur in the course of a study or work item.
Annex XC:
CR procedure in use by 3GPP WGs in 2025 for specifications in docx format
XC.1 Common aspects of the CR procedure
According to TR 21.900, “Once a specification has been approved by the TSG and version x.0.0 (where x >= 3, corresponding to the Release - see table 4 of TR 21.900) has been produced, it shall be considered to be under change control. Any technical change which may be identified for inclusion in the specification from this point on shall be accomplished by means of a Change Request (CR).”
XC.2 Initial submission and iteration of a p/CR
A p/CR proposes modifications to a Technical Specification (TS) or an external Technical Report (TR). The following process outlines typical p/CR handling: steps a) and b) cover initial submission, steps c) and d) cover treatment of p/CRs at the beginning of the meeting, steps from e) to g) detail the iteration phase during the meeting, and steps from h) to m) describe the finalization phase. The iteration phase is described generically, encompassing both at-meeting and post-meeting activities.
a) The p/CR author reserves a TDoc number for a new p/CR in the 3GU Portal and proceeds as follows.
1) Select in the portal the document type and fill in the meta-data: impacted specification, work item(s), Release number, and the CR category. If the document type is either pCR or draft CR, no CR number or revision number will be provided. Otherwise, a CR number and revision number will be provided by the portal.
2) Download the pre-filled CR template or the pCR template. Note the following guidance from TR 21.900: “It is strongly recommended that the author make use of this facility rather than filling in a blank CR cover from the stock template.”
3) Download the target version of the Technical Specification (TS) or Technical Report (TR) and propose modifications.
- Option 1: Edit the specification directly with track changes enabled and copy the modified clauses.
- Option 2: Copy clauses into the p/CR and edit them with track changes enabled.
4) Fill in any missing fields and isolated impact analysis and/or reason for change (if required) in the p/CR cover page.
5) Fill in the numbers of impacted clauses in the CR cover page.
6) Compress the document to ZIP format and rename the file only to contain the TDoc name.
7) Upload the p/CR via the 3GU portal.
b) Optionally or depending on the procedures of the WG, the specification rapporteur and the secretary review the p/CR prior to the meeting and proceed as described below. Note the following guidance from TR 21.900 regarding the role of the specification rapporteur: “Review all CRs to the specification prior to agreement in the Working Group. This includes identifying and resolving clashes”.
1) Download the TDoc list from the 3GU portal.
2) Download the CR, e.g., via the 3GU portal or FTP server.
3) Decompress the document to docx format.
4) Verify the correctness of the CR meta data on the CR cover page, ensure that the CR is prepared in accordance with specification drafting rules, and based on the target version of the TS or TR.
5) Inform the CR author and the meeting chairman or session chairman, e.g. via email, about any issues in the cover page or in the content of the CR.
c) The meeting chairman or session chairman takes notes of the received comments, e.g. via email, to decide actions regarding the CR treatment during the meeting.
d) If the p/CR reaches consensus during the meeting, the pCR will be implemented in the specification, the CR will be submitted to TSG subject for approval, and the process continues in step i). If the p/CR is not pursued, the process terminates. If the p/CR is deferred to offline discussion, the chairman assigns a company to gather feedback and come back with the outcome of the discussion where the scope of the offline discussion may encompass a single p/CR or multiple p/CRs. The p/CR author is tasked to author the p/CR revision, use a TDoc number allocated by the secretary, either prior to or after the offline discussion, and come back with p/CR revision(s).
e) The p/CR author makes a draft revision available to the group, e.g. via the FTP server, over email or other means according to the group’s practices, which can result in variations or duplicates of the same revision being modified independently. In larger working groups, the iteration may require sharing of documents, e.g., via FTP server- In that case, the collection of feedback can be carried out, for example as follows:
1) If FTP server is used, upload a draft revised p/CR or a discussion document to a folder as a starting point for the offline discussion.
2) May inform the working group about proposed changes to the p/CR e.g. via email reflector and request other companies to provide feedback or, given that FTP server is used, to upload further draft revisions of the p/CR or comments on the p/CR before the offline discussion deadline is passed. Interested companies may also directly monitor changes to the p/CR or the discussion document on the FTP server, and upload further draft revisions or comments, e.g., with tracked changes, without need for exchange of email.
f) In Interested companies may provide feedback on the p/CR, for example, in the following manner.
1) Infer the latest version of the revised p/CR or the discussion document, for example, from the working group naming convention, download the latest version from the folder and store it as a local copy.
2) Change the filename of the downloaded file in alignment with the working group naming convention (e.g. including company name, version number, etc.), propose modifications, and upload the modified local copy to the FTP server’s folder.
3) If a collision happens with other delegates concurrently modifying and uploading the same version, reiterate from step f1), i.e., re-edit all modifications from scratch in the latest version. Continue the reiteration until uploading is possible without collisions.
4) In some groups, feedback may also be provided over email, e.g. for specific wording suggestions
g) In case the draft version shall be uploaded as a new TDoc, the p/CR author submits the latest draft version as a TDoc subject for the whole working group discussion and decision including the following steps (if FTP server is used):
1) Download the latest version from the FTP server.
2) Request for a TDoc number unless already allocated prior to the offline discussion.
3) Update the p/CR cover page including updated revision history, rename the file to the TDoc number and compress to zip format.
4) Upload the TDoc, e.g., to Inbox folder of FTP server or 3GU portal, with the new TDoc number as zip file name.
h) The p/CR author presents the revision, and the process continues as described in step d).
i) The specification rapporteur implements the approved pCRs.
j) The secretary prepares CR packs for TSG submission This step does not apply to pCRs.
1) Allocate TSG CR pack numbers.
2) Download WG TDoc list and manually add a CR pack number to the agreed CR.
3) Upload the modified TDoc list to 3GU portal for automatic generation of CR packs.
4) Download the CR packs from 3GPP FTP server and submit them via 3GU portal for TSG approval.
k) The secretary implements approved CRs.
1) Download the TSG TDoc list and approved CR packs.
2) Download the latest versions of the specifications.
l) The specification rapporteur reviews the draft CR implementation.
1) Download the draft specification from 3GPP FTP server. Verify the correctness of the CR implementation against the approved CR.
2) If there are errors, the secretary creates a new draft until the implementation is correct.
m) The specification is published via 3GU portal, and the CR database is updated.
XC.3 Specific aspects of the CR procedures
Editor’s note: Other WGs will be considered during the study and have been considered as part of the common procedures in clause XC.1 and XC.2.
XC.3.1 Cross-WG aspects
DraftCR used by a Working Group (WG A) for changes to a specification under responsibility of WG B: The draftCR does not get a CR number in WG A. Revision history on the cover page of the draftCR can’t be filled in due to absence of revision number. After a draftCR has been endorsed by WG A, it is transferred to the WG B for agreement. The WG B turns the draftCR into a CR and allocates a CR number. If WG B agrees the CR, it is further transferred to TSG for approval.
XC.3.2 RAN3 aspects
RAN3 handles CRs for corrections and technical enhancements and improvements (TEI) as described in clause XC.2.
For handling of baseline CRs there are several differences. These differences are described here also including excerpts from RAN3’s internal TR 30.531 which provides the detailed procedure e.g. rules for use of tracked changes.
- TR 30.531 clause 5.3.2 bullet 10: “For complex issues which cannot be solved in one meeting, it is encouraged to use Baseline CRs. A Baseline CR is used as a container CR, incorporating individual agreeable proposals of CRs. ”
Initial submission: Some cover sheet information (reason for change, summary of change, consequences if not approved, clauses impacted, linked specifications) may be missing from the baseline CR upon initial submission. This information is often added when baseline CR content becomes stable towards the completion of the work item, by the baseline CR editor or during the final CR review. TR 30.531 provides the following instructions for baseline CR submission to the meeting:
- At the beginning of each meeting, the editor of a baseline CR must resubmit the last endorsed version of the baseline CR. Any editorial changes from the editor of the baseline CR must be marked by a different username for track changes than the username used for the changes from the agreed text proposals.
- It is the baseline CR editor's responsibility to make sure at all times that there are no changes on changes in the baseline CR.
- It is encouraged to use a CR number also for the Baseline CR and update the revision number with each new revision. This way it is clear which version of the baseline CR is being discussed. In the end of the meeting the Baseline CR is marked as "Endorsed" in the meeting minutes.
At-meeting iteration: The submitted baseline CR is re-endorsed at the start of the meeting. Input for at-meeting iteration of the baseline CRs is provided in Text Proposals (TPs) submitted to the meeting. One or more TP moderators are nominated to merge input from different companies into TP(s) that will be agreed during the meeting week. TR 30.531 provides the following instructions for TP preparation and submission:
- When requesting a TDoc to propose changes/updates to a baseline CR, one should use the Tdoc type "other” and indicate in the abstract the TDoc of the baseline CR that the changes are targeting.
- Text proposals for changes/updates to the baseline CR must keep the track changes from the latest endorsed version of baseline CR (i.e. DO NOT accept the changes already existing in the baseline CR) and must use a different user name, in MS Word's Track Change Options, for the new proposed changes (different user name than the one used in the baseline CR track changes). Also, Do NOT use CR cover page in text proposal to the baseline CR documents.
Aggregation of CRs into a running p/CR or mega p/CR – Post-meeting treatment of a p/CR: The baseline CR editor will implement agreed TPs during post-meeting email review. TR 30.531 provides the following instructions for this step:
- If the proposal from the TDoc type "other", is agreeable, the TDoc will be merged in the Baseline CR with a TDoc Status: "agreed".
- After each meeting, the baseline CR editor must provide, as soon as possible in the RAN3 email reflector, a draft implementation of all agreed proposals. When implementing an agreed text proposal, the baseline CR editor must set the username in MS Word's Track Change Options equal to TDoc number of the document from which the changes are coming. The baseline CR editor must maintain, in "This CR's revision history" field of the cover page, the list of Tdoc numbers of the agreed and implemented text proposals.
- At the deadline of the email review, the editor of a baseline CR has to provide the final version of the baseline CR using the TDoc number allocated by MCC. In this version, only one single username must be used in the Track Change Options for all the changes from the different agreed text proposals.
XC.3.3 SA2 aspects
SA2 agrees many CRs and pCRs at each meeting. Before the meeting, TDOC numbers are assigned to CRs and pCRs using the 3GPP portal; for CRs, CR numbers are also assigned in that manner.
For physical SA2 meeting, only the author can provide revisions of CR and pCRs, but other companies typically suggest multiple updates in email discussions or during offline drafting sessions, making use of changemarks, different authors, and text highlights to distinguish the changes. It is also a frequent praxis that not all input documents are opened during an SA2 meeting due to time constraints, but the authors of similar CRs or pCRs work together to merge their contents, again making use of different authors and colour coding to show the different origins of changes.
For e-meetings, between official CR or pCR versions (with separate TDOC numbers) any company can provide revisions and any of those versions can be agreed and made a new official CR version. There are conventions for numbering those CR revisions in a way that allows any company to provide them without MCC support and number clashes (TDOC number and CR revision number remain unchanged, but “revn” is appended to TDOC numbers, where “n “is the next free number). Those revisions typically are based on the last previous revision, and change marks, different authors, and text highlights are used to highlight the new changes.
There are typically several revisions of a CR or pCRs before agreement. CR or pCR revisions (with new TDOC numbers) during the meeting are assigned by SA2(vice) chairs, possibly without immediate MCC support, and may not be immediately visible in 3GPP databases and 3GPP tooling. The presentation of CR revisions is expected to be brief and focus on changes compared to previous versions; the chairs display those revisions on the screen and colour coding of new changes is important to aid this process.
If two SA2 meetings occur between an SA plenary, no new versions of 3GPP specs will be made available by MCC after the first meeting. Thus, there is a frequent need to update CRs agreed at the 1st SA2 meeting during the 2nd SA2 meeting, e.g. due to textual overlaps. In such cases, any company can request a new revision of an agreed CR, and new changes that discussions should focus upon are expected to be highlighted (although also changes from the 1st SA2 meeting are still shown with change marks).
Time for delegates to review CR versions, and time in the end of SA2 meeting week to fix minor mistakes is very limited. Normally CRs are pre-agreed, the author is tasked to produce a “clean” version (no changes-on-changes or colour highlights), possibly also with some extra updates captured by the chair, and the final CR version is not presented. However, there is a possibility for delegates to check pre-agreed CRs before the close of the SA2 meeting and the final so called “block-approval” and to request CRs to be revised to fix mistakes.
Annex CD:
Change history
Change history
Date
Meeting
TDoc
CR
Rev
Cat
Subject/Comment
New version
2025-07
6GSM#01
6GSM-250008
Endorsed TR Skeleton
0.0.0
2025-08
6GSM#02
6GSM-250101
Inclusion of endorsed pCRs 6GSM-250041, 6GSM-250045, 6GSM-250046, 6GSM-250048, 6GSM-250050
0.0.1
2025-09
6GSM#02
6GSM-250131
Inclusion of endorsed pCRs 6GSM-250107, 6GSM-250108, 6GSM-250121, 6GSM-250125, 6GSM-250126,
6GSM-250127, 6GSM-250128, 6GSM-250129,
6GSM-250130
0.0.2
2025-09
SA#109
SP-251075
Further editorial cleanup and submission to TSG SA/CT/RAN joint session for review.
0.1.0
2025-09
SA#109
Additional editorial cleanup including cover page after SA#109
0.1.1
2025-10
6GSM#03
6GSM-250201
Inclusion of endorsed pCRs: 6GSM-250216, 6GSM-250218, 6GSM-250228, 6GSM-250230, 6GSM-250234, 6GSM-250236, 6GSM-250237, 6GSM-250238, 6GSM-250240, 6GSM-250241, 6GSM-250243
0.1.2
|
428ebcbeb0eb2c154ced279909b86323 | 28.887 | 1 Scope
| The present document studies and assesses enhancements to the management aspects of management data, focusing on data discovery, data collection, data storage, data access etc., for 5G-Advanced. The study aims to identify the new functionalities, or enhancement to the data management capabilities and propose potential solutions.
|
428ebcbeb0eb2c154ced279909b86323 | 28.887 | 2 References
| The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
- References are either specific (identified by date of publication, edition number, version number, etc.) or non‑specific.
- For a specific reference, subsequent revisions do not apply.
- For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document in the same Release as the present document.
[1] 3GPP TR 21.905: "Vocabulary for 3GPP Specifications".
…
[x] <doctype> <#>[ ([up to and including]{yyyy[-mm]|V<a[.b[.c]]>}[onwards])]: "<Title>".
|
428ebcbeb0eb2c154ced279909b86323 | 28.887 | 3 Definitions of terms, symbols and abbreviations
| |
428ebcbeb0eb2c154ced279909b86323 | 28.887 | 3.1 Terms
| For the purposes of the present document, the terms given in TR 21.905 [1] and the following apply. A term defined in the present document takes precedence over the definition of the same term, if any, in TR 21.905 [1].
example: text used to clarify abstract rules by applying them literally.
|
428ebcbeb0eb2c154ced279909b86323 | 28.887 | 3.2 Symbols
| For the purposes of the present document, the following symbols apply:
<symbol> <Explanation>
|
428ebcbeb0eb2c154ced279909b86323 | 28.887 | 3.3 Abbreviations
| For the purposes of the present document, the abbreviations given in TR 21.905 [1] and the following apply. An abbreviation defined in the present document takes precedence over the definition of the same abbreviation, if any, in TR 21.905 [1].
<ABBREVIATION> <Expansion>
|
428ebcbeb0eb2c154ced279909b86323 | 28.887 | 4 Use Cases
| 4.1 Request and Report of External Management Data
|
428ebcbeb0eb2c154ced279909b86323 | 28.887 | 4.1.1 Use Case#1: Time Issue of External Management Data
| 4.1.1.1 Description
External management data are modelled in TS 28.622[X] by ExternalDataType IOC (clause 4.3.73). This IOC defines attributes to indicate the type of external management data and related meta data.
Specified meta data are
- mediaLocation: “address from which the described external management data can be retrieved. “
- externalDataTypeSchema: “URI where the MnS consumer can get the schema to parse the external management data.”
- externalDataScope: “concrete scope (e.g., geographical areas) which the external management data is applicable.”
4.1.1.2 Problem Statement
The attribute mediaLocation of IOC ExternalDataType specifies the endpoint where to retrieve the external management data. However, there is no indication on the validity of this data on a time scale. E.g. for which period of time applies the provided external data is applicable. Is this a record of the past, or a prediction for the future. The information of time is of importance in case of a request for historical data as well as for present data or for future data.
The explicit information of time regarding the requested or reported external management data is missing.
4.1.1.3 Potential Requirements
Editor’s Note: This clause is to describe potential requirements for the identified issue.
4.1.1.4 Potential Solution
Editor’s Note: This clause is to discuss possible solutions for the identified issue.
4.2 UE Data Collection
4.2.A Use Case#<A>: <Title>
4.2.A.1 Description
4.2.A.2 Problem Statement
4.1.A.3 Potential Requirements
4.1.A.4 Potential Solution
4.3 Enhancement of Management Services Access Control (MSAC)
4.3.A Use Case#<A>: <Title>
4.3.A.1 Description
4.3.A.2 Problem Statement
4.1.A.3 Potential Requirements
4.1.A.4 Potential Solution
4.4 Clarification of Mechanisms to Discover, Request and Retrieve Management Data
4.4.A Use Case#<A>: <Title>
4.4.A.1 Description
4.4.A.2 Problem Statement
4.1.A.3 Potential Requirements
4.1.A.4 Potential Solution
|
428ebcbeb0eb2c154ced279909b86323 | 28.887 | 5 Conclusion and Recommendations
| Editor’s Note: This clause is to summarize the identified key items and to discuss recommendations for a potential Work Item.
5.1 Request and Report of External Management Data
5.2 UE Data Collection
5.3 Enhancement of Management Services Access Control (MSAC)
5.4 Clarification of Mechanisms to Discover, Request and Retrieve Management Data
Annex <A> (informative):
Change history
Change history
Date
Meeting
TDoc
CR
Rev
Cat
Subject/Comment
New version
2025-08
SA5#162
Initial skeleton
V0.0.0
2025-08
SA5#162
S5-253500
Pseudo-CR on Time Issue of External Management Data
0.1.0
2025-08
SA5#162
S5-254047
Pseudo-CR on TR structure for 28.887
0.1.0
2025-10
SA5#163
S5-254894
Pseudo-CR on Introduction for data management phase-3
0.2.0
2025-10
SA5#163
S5-254895
Pseudo-CR on Scope for data management phase-3
0.2.0
2025-10
SA5#163
S5-254689
Pseudo-CR on Time Issue of External Management Data
0.2.0
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 1 Scope
| The present document …
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 2 References
| The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
- References are either specific (identified by date of publication, edition number, version number, etc.) or non‑specific.
- For a specific reference, subsequent revisions do not apply.
- For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document in the same Release as the present document.
[1] 3GPP TR 21.905: "Vocabulary for 3GPP Specifications".
[2] 3GPP TS 38.300: "NR and NG-RAN Overall Description; Stage 2".
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 3 Definitions of terms, symbols and abbreviations
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 3.1 Terms
| For the purposes of the present document, the terms given in TR 21.905 [1] and the following apply. A term defined in the present document takes precedence over the definition of the same term, if any, in TR 21.905 [1].
example: text used to clarify abstract rules by applying them literally.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 3.2 Symbols
| For the purposes of the present document, the following symbols apply:
<symbol> <Explanation>
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 3.3 Abbreviations
| For the purposes of the present document, the abbreviations given in TR 21.905 [1] and the following apply. An abbreviation defined in the present document takes precedence over the definition of the same abbreviation, if any, in TR 21.905 [1].
<ABBREVIATION> <Expansion>
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 4 Concepts and overview
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5 Management capabilities for AI/ML lifecycle
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1 ML model training
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1 Use cases
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.1 Management support to training for UE-side model
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.1.1 Management support to AI/ML-based beam management
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.1.1.1 Description
| To support AI/ML-based beam management defined in TS 38.300 [2], for beam prediction management, UE can send the data of beam prediction management to UE-side training entity (e.g. a server inside MNO or an OTT server) via gNB and 3GPP management system for UE-side model training (see NOTE 1). 3GPP management system needs to collect data from gNB and report it to UE-side training entity to management support of training for UE-side model.
Figure 5.1.1.1.1.1-1: Management of UE-side data collection and reporting for UE-side model training
Being a MnS consumer, the UE-side training entity requests 3GPP management system to collect the UE-side data of beam prediction management, then 3GPP management system configure the gNB(s) to collects data from specified UEs, and gNB shall send configuration information to the UE(s). The request from UE-side training entity shall include the type of data (e.g. based on UE/UE Group, location, time) to be produced and the gNB(s) where the data shall be collected.
After the UE-side training data such as beam prediction data are produced, UE(s) shall report the UE-side data to gNB(s), and 3GPP management system shall collect data from the gNB(s). 3GPP management system report the collected data to UE-side training entity depending on access information specified by operator (see NOTE 2).
NOTE 1: The UE-side data are subject to further discussion, pending ongoing correspondence and confirmation by RAN2 and RAN1.
NOTE 2: Access control information is for further discussion.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.1.1.2 Potential requirements
| REQ-ML_UESIDE-01: The 3GPP management system should have a capability allowing the authorized UE-side training entity to request the UE-side training data for the UE-side model training.
REQ-ML_UESIDE-02: The 3GPP management system should have a capability to request and get the UE-side training data from gNB(s) for the UE-side model training.
REQ-ML_UESIDE-03: The 3GPP management system should have a capability to report the UE-side data to authorized UE-side training entity for UE-side model training.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.1.1.3 Possible solutions
| TBD
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.1.1.4 Possible solutions evaluation
| TBD
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.2 Management support to OAM-centric training for NG-RAN NW-side model
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.2.1 Management support to AI/ML-based beam management
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.2.1.1 Description
| To support AI/ML-based beam management defined in TS 38.300 [2], UE can provide data of beam management to 3GPP management system via gNB (see NOTE 1). 3GPP management system needs to collect data from gNB for OAM-centric training for NG-RAN NW-side model.
Figure 5.1.1.2.1.1-1: Management of NW-side data collection and reporting for NW-side model training
The 3GPP management system request gNB(s) to collect the NW-side training data of beam management and provides the configuration to gNB(s), then gNB(s) shall send configuration information to the UE(s) for NW-side training data collection. After the NW-side training data are produced, UE(s) shall report the NW-side training data to gNB(s), and 3GPP management system shall collect data from the gNB(s). 3GPP management system collect data should depend on access control information specified by operator (see NOTE 2).
NOTE 1: The OAM centric NW-side training data are subject to further discussion, pending ongoing correspondence and confirmation by RAN2.
NOTE 2: Access control information is for further discussion.
Editor notes: The need for user consent is pending ongoing correspondence and confirmation by SA3 and RAN2.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.2.1.2 Potential requirements
| REQ-ML_NWSIDE-01: The 3GPP management system should have a capability to configure the NW-side training data collection for OAM-centric NW-side model training.
REQ-ML_NWSIDE-02: The 3GPP management system should have a capability to obtain the NW-side training data for OAM-centric NW-side model training.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.2.1.3 Possible solutions
| TBD
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.2.1.4 Possible solutions evaluation
| TBD
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.3 Management of Vertical Federated Learning
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.3.1 Description
| In Rel-19, Vertical Federated Learning (VFL) is introduced in core network for NWDAF(s) and AF(s).There may be one NWDAF or one AF acting as a VFL server and one or multiple NWDAF(s) and/or one or multiple AF(s) acting as VFL Client(s). Vertical Federated Learning is available among NWDAFs or between NWDAF(s) and AF(s) within a single PLMN or between an AF and NWDAF(s) in a single PLMN. When AF is acting as VFL Server, NWDAF(s) is VFL Client(s).
In Rel-19, federated learning is introduced in the 3GPP management system for multiple ML training functions. The MnS Consumer can specify the FL Requirements in ML Training Request for FL process, where the FLClientSelectionCriteria including the consumer’s requirements on sample (e.g., minimumAvailableDataSamples) for clients selection. However, current mechanism doesn’t allow the consumer to specify requirements on feature for client selection in VFL process. Since HFL and VFL are two distinct paradigms within the broader framework of FL, in VFL process, participants possess different feature space for potentially overlapping samples, which is ideal and beneficial to be introduced in management system. Since the MLTFunctions within the operator domain may be located in cross-domain management system, RAN domain management system and Core domain management system, available datasets for these MLTFunctions may share common samples but offer complementary features. The sample alignment is needed to ensure that different VFL participators share the same sample space before initiating VFL process.
The model training approach for HFL and VFL is also different. Training method allows each VFL Client owning its own local model but not needing to share the same model architectures, since different feature space in VFL Clients may lead to different structures for local models. But the intermediate information of the interaction is implementation specific. The VFL training architecture is fully applicable to the characteristics of management system and can fully exploit the potential of data in management system. This use case proposes to support management of VFL leveraging sample alignment among the entities participating in VFL process.
NOTE 1: The technical details of how the sample alignment is performed, including specific algorithms or mechanisms for matching or encrypting sample identifiers, remain proprietary and are outside of the scope 3GPP SA5.
NOTE 2: The management coordination in VFL process is only applicable within the operator domain.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.3.2 Potential Requirements
| REQ-VFL_MGMT-01: The ML training MnS producer should have a capability allowing an authorized consumer to get the VFL role (VFL server or VFL client) of an ML Training Function in VFL process.
REQ-VFL_MGMT-02: The ML training MnS producer should have a capability allowing an authorized consumer to specify requirements on sample alignment for client selection in VFL.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.3.3 Possible solutions
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.1.1.3.4 Possible solutions evaluation
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.2 ML model testing
| Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.3 AI/ML inference emulation
| Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.4 ML model deployment
| Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 5.5 AI/ML inference
| Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 6 AI/ML sustainability
| |
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 6.1 Sustainability for ML training
| Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 6.2 Sustainability for AI/ML inference
| Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 7 Registration and discovery for AI/ML
| Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 8 Relation with other management capabilities
|
Editor’s note: Similar clause structure as in subclause 5.1 will be adopted.
|
ed510c38c71cbc9cca8176fcc780259b | 28.882 | 9 Conclusion and recommendations
|
Annex A (informative):
Change history
Change history
Date
Meeting
TDoc
CR
Rev
Cat
Subject/Comment
New version
2025-08
SA5#162
Initial skeleton
0.0.0
2025-10
SA5#163
S5-254664
S5-254666
S5-254667
S5-254744
pCR
pCR
pCR
pCR
pCR TR 28.882 initial ToC
Pseudo-CR on TR 28.882 add Management support to UE-Side model training use case
Pseudo-CR on TR 28.882 add Management support to NW-Side model training use case
Pseudo-CR on TR 28.882 Add New Use Case on Management of Vertical Federated Learning
0.1.0
|
042d302ca200c9423b759396ac85b7c9 | 28.883 | 1 Scope
| The present document …
|
042d302ca200c9423b759396ac85b7c9 | 28.883 | 2 References
| The following documents contain provisions which, through reference in this text, constitute provisions of the present document.
- References are either specific (identified by date of publication, edition number, version number, etc.) or non‑specific.
- For a specific reference, subsequent revisions do not apply.
- For a non-specific reference, the latest version applies. In the case of a reference to a 3GPP document (including a GSM document), a non-specific reference implicitly refers to the latest version of that document in the same Release as the present document.
[1] 3GPP TR 21.905: "Vocabulary for 3GPP Specifications".
[2] 3GPP TS 28.312: " Management and orchestration; Intent driven management services for mobile networks".
[3] 3GPP TS 28.561: " Management and orchestration; Management aspects of Network Digital Twins".
[4] 3GPP TS 28.532: "Management and orchestration; Generic management services".
|
042d302ca200c9423b759396ac85b7c9 | 28.883 | 3 Definitions of terms, symbols and abbreviations
| |
042d302ca200c9423b759396ac85b7c9 | 28.883 | 3.1 Terms
| For the purposes of the present document, the terms given in TR 21.905 [1] and the following apply. A term defined in the present document takes precedence over the definition of the same term, if any, in TR 21.905 [1].
example: text used to clarify abstract rules by applying them literally.
|
042d302ca200c9423b759396ac85b7c9 | 28.883 | 3.2 Symbols
| For the purposes of the present document, the following symbols apply:
<symbol> <Explanation>
|
042d302ca200c9423b759396ac85b7c9 | 28.883 | 3.3 Abbreviations
| For the purposes of the present document, the abbreviations given in TR 21.905 [1] and the following apply. An abbreviation defined in the present document takes precedence over the definition of the same abbreviation, if any, in TR 21.905 [1].
<ABBREVIATION> <Expansion>
|
042d302ca200c9423b759396ac85b7c9 | 28.883 | 4 Concepts and background
| Editor’s note: This clause provides a description of concepts and background.
|
042d302ca200c9423b759396ac85b7c9 | 28.883 | 5 Use cases
| |
042d302ca200c9423b759396ac85b7c9 | 28.883 | 5.1 Use Case #1: NDT support intent pre-evaluation
| 5.1.1 Description
TS 28.312 [1] introduces the intent pre-evaluation which includes Intent Feasibility check and Intent Exploration. Intent feasibility check enables the MnS consumer to check if the proposed intent can be supported by the MnS producer. Intent exploration enables the MnS consumer and the MnS producer to find the intent for fulfilment that is best aligned with MnS producer's capabilities. NDTF can be used to support for intent pre-evaluation.
The relation between NDTF and Intent Handling Function follows the relation between NDTFs and network automation functions defined in TS 28.561 clause 4.3. An adaption figure based on Figure 4.3-1 in TS 28.561 is shown below.
Figure 5.X.1-1: Relation between NDTF and Intent Handling Function
In the scenario of radio network/service intent pre-evaluation, the MnS consumer may request to obtain the best values for a given target or context, e.g., the number of terminal devices. NDTF can support intent handling function to evaluate the number of terminal devices (e.g., UE) given certain simulation conditions, such as intent objects scope (e.g., area scope, cell lists, civic address, etc), intent object type (e.g., radio service, radio network, etc). IHF requests NDTF to simulate the network performance under various conditions, NDTF simulates the network performance and reports to IHF with simulation results.
This use case proposes to enhance the description related to network automation in TS 28.561 to capture the relationship between NDT and IHF and specify that NDT can support network automation capability including intent pre-evaluation.
|
042d302ca200c9423b759396ac85b7c9 | 28.883 | 5.1.2 Potential requirements
| No new requirements
5.1.3 Potential solutions
5.1.4 Evaluation of potential solutions
|
042d302ca200c9423b759396ac85b7c9 | 28.883 | 5.2 Use Case #2: Improvement of data generation
| |
042d302ca200c9423b759396ac85b7c9 | 28.883 | 5.2.1 Description
| TS 28.561 clause 5.4.2.2 [3] introduces the data generation capability provided by NDT to enable ML training. For different ML models, the preferences of its training data are different, which can vary in the dimension of data source object, data type, data quantity. The data source object is used to specify the simulated object from which the synthetic ML training data is collected. It is the subset of the NDT synchronization objects. The data quantity is used to specify how many data needs to be reported by NDT for ML training.
The existing solution of NDT NRMs can support the data generation by specifying data source objects and data type to be collected. The data source objects can be specified by the managedEntitiesScope defined in ScopeDefinition <<choice>> which represents the synchronization scope. The data type can be specified by the simulationData defined in SimulationDataDescriptor <<dataType>>. However, the existing solution cannot satisfy the data generation scenario where the requested data source objects are the subset of the synchronized network objects with specific data quantity.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.