Comprehensive Guide to Creating XML Documents Effectively

XML document structure showcasing elements and attributes

Prolusion to Documents

When it comes to representing structured data, XML, short for eXtensible Markup Language, offers a flexible way to create information formats. It allows users to define their own tags, tailor the structure to their data needs, and share information across different systems seamlessly. This document is intended to serve as a comprehensive guide for individuals seeking to delve deeper into the world of XML and its applications.

The relevance of XML spans various industries, from web development to data management and beyond. It is used in configuration files, data interchange between applications, and even in document formats like Microsoft Word and XHTML. With the increasing significance of data interoperability in our digital landscape, understanding XML becomes invaluable.

With this guide, you will learn not just the nuts and bolts of XML syntax but also practical examples and the real-world implications of using XML effectively. Prepare to embark on a journey to becoming an XML aficionado!

Basic Syntax and Concepts

To get a solid foundation, it's crucial to understand the basic syntax of XML and some key concepts that govern its structure. XML is not just a markup language; it is a way of framing your data in a tree-like structure that machines can easily parse and understand.

Structure of Documents

An XML document starts with a declaration, followed by the root element, which contains all other elements. For instance:

xml ?xml version="1.0" encoding="UTF-8"?> data> item> name>Example Itemname> value>123value> item> data>

This document defines a collection of products, where each product has a name and a price associated with it. As you experiment with XML documents, attempt to add more attributes or nested elements to foster learning and understanding.

Resources and Further Learning

To expand your knowledge of XML, various resources can offer substantial insights and tutorials:

Books: XML in a Nutshell by Elliotte Rusty Harold is a great starting point.
Online Courses: Platforms like Coursera and Udemy offer XML-related courses for different skill levels.
Community Forums: Engage with communities on Reddit's /r/XML or Facebook groups dedicated to XML and data formats.

Each of these resources can help deepen your understanding and provide real-world examples that can subsequently enhance your XML skill set.

"Understanding XML is not just about knowing syntax; it's about grasping how to structure data logically and efficiently."

This journey does not end here. As you step into the realm of XML, remember: practice is key. With time and dedication, your skills can flourish, enabling you to communicate data in ways that both humans and machines understand.

Intro to

In the realm of data representation, XML plays a crucial role, not just as a format but as a bridge linking disparate systems and applications. Understanding XML is essential, particularly for individuals stepping into the world of programming and data management. This introduction serves as a launchpad into the intricate world of XML, highlighting its importance, versatility, and the practical applications it offers.

Definition and Purpose

XML, short for Extensible Markup Language, is a flexible text format derived from SGML (Standard Generalized Markup Language). Unlike HTML, which is primarily designed for displaying data, XML is designed to transport and store data. This transportability means that XML can be integrated seamlessly across varying platforms.

The primary purpose of XML is to facilitate data interchange between systems in a structured manner. By employing a self-descriptive format, XML documents allow users to understand the data contents without requiring additional information. For instance, consider an e-commerce application that utilizes XML to send product information. Vendors could easily share product descriptions, prices, and inventory levels in a standardized format.

Benefits of XML include:

Data Interoperability: Allows different applications to share data without compatibility issues.
Hierarchical Structure: Enables a tree-like structure that represents complex data in a coherent manner.
Human-Readable: It maintains a format that developers and users can easily read and edit.

Differences Between and Other Markup Languages

HTML is primarily used to create web pages and present data. In contrast, XML focuses on the storage and transport of data. For example, an HTML document may display a menu, but an XML document can store the menu items along with their ingredient details, allowing for dynamic generation in various settings.

Key differences include:

Purpose: HTML for presentation, XML for data transport.
Structure: XML allows custom tags, while HTML has predefined tags.
Flexibility: XML is extensible, whereas HTML is limited to its set of tags.

"XML is like a backbone – it supports the body of data in a way that is flexible and expandable."

Understanding these differences equips readers with the foundational knowledge necessary for effective XML document creation. As you dive deeper into the nuances of XML, this differentiation will become crucial as you encounter various scenarios where XML could be beneficial.

By grasping the fundamentals outlined here, you set the stage for a thorough comprehension of how XML can be utilized across numerous applications and programming languages. For those interested in delving into the technical specifics of XML, resources can be found at Wikipedia or Britannica.

Understanding Structure

Understanding the structure of XML documents is paramount for any individual venturing into the world of data representation. The XML format is not just a method of organizing data; it is a blueprint of information, capable of efficiently encoding a wide array of data types. To grasp XML’s relevance, it’s essential to break down its core components into manageable parts: the basic syntax rules, elements, attributes, and hierarchy. This foundation sets the stage for effective document creation, ensuring that users can create XML that is not only functional but also clearly understood by both humans and machines.

Basic Syntax Rules

At first glance, XML can seem a bit like a riddle wrapped in an enigma—it has rules, and breaking them can lead to chaos. Knowing the basic syntax rules is vital for anyone trying to piece together a valid XML document. Here’s a rundown of the essential syntax guidelines:

Every XML document must have a single root element. Think of it as the overarching framework that holds everything together.
Elements must be properly nested; you cannot have a misalignment, as it breaks the structure. Misplacing an opening or closing tag can lead to a mess.
Tags are case-sensitive, so and are not the same. This small detail can trip up even seasoned programmers.
Each element can include optional attributes that provide additional information, but these must appear within the opening tag.

A simple XML document enforcing these rules could look something like this:

xml Library> Book author="John Doe"> Title>Learning XMLTitle> Year>2023Year> Book> Library>

Code editor displaying XML syntax highlighting

After this declaration, it’s wise to create a root element. Every XML document must have one and only one root element that encompasses all other elements. For instance, if you’re creating a document about books, you might start with:

Taking these initial steps ensures your document adheres to XML structure, preventing errors later on.

Defining Elements

Once your document is set up, the next logical move is defining the elements. Elements are the building blocks of your XML document; they encapsulate data and provide structure. In our library example, you could define a book element like this:

Notice how we’re nesting elements within "book". This hierarchy not only keeps data organized but also conveys relationships among the data. The way you arrange your elements can significantly affect how the data is interpreted down the line. Therefore, it's vital to think carefully about the structure you want to create.

Adding Attributes

Lastly, attributes can provide additional information about elements without cluttering the main content. They’re a way to add detail while keeping the XML clean and organized. For instance, if you want to add a publication year to your book element, you could do it like this:

In this example, "published" is the attribute giving more context to the book element itself. Using attributes judiciously can enhance the clarity of your data model, making it easier to parse later on. But remember to keep a balance; overcrowding elements with attributes can lead to confusion.

In summary, creating your first XML document involves careful planning and a structured approach. You define the basic structure, establish elements, and refine your data with attributes. Embracing these principles not only equips you with vital skills but also lays the groundwork for more complex XML usages in the future.

Common Practices in Creation

Creating XML documents is not just about getting the syntax right; it’s also about following certain common practices that enhance the overall quality and functionality of the document. Adopting these practices can save significant time and effort, improve collaboration, and ensure that your XML files serve their intended purposes effectively. Let’s delve into some of these pivotal practices.

Consistency and Readability

In the world of XML, consistency is king. When you're knee-deep in a project, maintaining a consistent approach to element naming, indentation, and spacing becomes crucial. If you name an element "ProductID" in one part of your document, don’t switch it up to "prodID" or "ID_Prod" elsewhere. Keep it uniform. This not only aids in readability but also in understanding and maintaining the document’s structure.

Indentation: Use clear indentation for nested elements. Properly indented XML is like a well-planned roadmap; it makes it easier for others (or you later on) to follow. For example:xml Products> Product> ProductID>1234ProductID> Name>Example ItemName> Product> Products>

Here, the indentation shows how the elements are nested.

Attribute Usage: It’s advisable to be strict with how you use attributes. For instance, prefer using child elements for complex data. Attributes are best for simple state information. If your XML resembles a jumbled mess, you can bet it’s going to be a headache for anyone trying to decipher it.

With consistent and readable XML, sharing your work becomes a seamless experience.

Using Comments Effectively

Comments in XML are often like bread crumbs in a forest - they help guide you through the wilderness of code. Adding comments isn't just a luxury; it’s a necessity for effective communication. They allow you to explain the purpose of certain sections of the XML, making it easier for others (and future you) to understand the thought process behind the decisions you made.

Explain Why, Not What: Instead of stating the obvious, like "Name>John DoeName> is the name of the person," use comments to explain decisions. Like:
Document Changes: If you make significant changes to an XML file, it's good practice to note these in the comments. It serves as a valuable reference point for anyone looking back later.

John Doe is a placeholder name for demonstration purposes.

For instance:

Updated ProductID format to adhere to new standards on 2023-11-15

Using comments wisely can significantly enhance the maintainability of your XML document, making it more user-friendly while preventing the dreaded communication breakdowns often found in coding.

By practicing these fundamentals, not only do you boost your own efficiency, but you also lay a strong foundation for future collaboration and scalability. Remember, quality XML isn’t just in the code; it’s also in how that code speaks to its readers.

Validating Documents

Validating XML documents is an essential part of ensuring the integrity and correctness of the data structures we use. It allows developers and data architects to confirm that XML documents adhere to defined standards, potentially preventing a cascade of errors later in the data handling process. Correct validation helps in various ways, from detecting simple syntax inconsistencies to ensuring the overall data integrity against a set schema.

Foreword to Validation

XML validation is the process of checking whether the XML document complies with certain rules and structures. These rules can be defined using a DTD (Document Type Definition) or an XML Schema. Validation plays a crucial role, particularly when XML documents are shared across different systems or need to comply with specific standards. By validating XML, you can catch errors in the early stages, which is far less costly than dealing with them after the fact. Validation acts like a safety net, ensuring that the data is not only syntactically correct but also semantically valid. This step is vital in fields where precise data representation matters immensely, such as in finance or health care. It saves time and mitigates future issues significantly.

Using DTD for Validation

A DTD, or Document Type Definition, specifies the structure of an XML document. It defines the legal building blocks of an XML document, such as elements, attributes, and entities. When using DTD for validation, an XML document is compared against this defined structure to ensure compliance.

To illustrate, a basic DTD might look like this:

xml !DOCTYPE note [ !ELEMENT note (to, from, heading, body)> !ELEMENT to (#PCDATA)> !ELEMENT from (#PCDATA)> !ELEMENT heading (#PCDATA)> !ELEMENT body (#PCDATA)> ]>

Comparison chart of XML versus JSON data formats

This schema approach allows for more intricate rules, such as defining acceptable formats (like specific date formats or numeric ranges), which can be invaluable in ensuring correctness of complex datasets. In the long run, while DTD might fit straightforward uses, XML Schema is where many developers find the flexibility and power they need for comprehensive validation.

Validating XML documents is not just a good practice; it is practically a necessity in today’s data-driven world. Integrating DTD or XML Schema validation into your XML management workflow can vastly improve the quality of your applications and reduce future headaches while handling XML data errors.

Remember: Proper validation helps maintain trust in the data, which is crucial for both businesses and end-users alike.

For more information on XML validation, consider visiting the Wikipedia page on XML Schema or the W3C’s XML Specifications.

Parsing Techniques

Parsing XML documents is a pivotal step in the manipulation and extraction of data from these structured files. By employing XML parsing techniques, developers can effectively interpret the information stored within the tags and attributes, making it accessible for various applications. Whether you’re looking at XML in web services, APIs, or data storage, understanding these parsing techniques can significantly impact your efficiency and effectiveness in working with XML data.

What is Parsing?

XML parsing refers to the process of reading and interpreting XML documents. It’s about converting the textual representation of XML into a format that can be easily manipulated by programs. In simpler terms, if XML is the book, parsing is akin to reading its chapters to extract information kept therein. This step is crucial for any application that needs to process XML data, allowing the program to convert it into an object representation or feed it to other functions that require structured data.

Different Parsing Approaches

When it comes to XML parsing, there are several approaches available, each with its own strengths and weaknesses. The choice largely depends on the specific requirements of your project, such as performance needs, memory usage, or the complexity of the XML structure. Here are the three main methods:

DOM Parsing

DOM (Document Object Model) Parsing involves loading the entire XML document into memory and representing it as a tree structure. This allows for easy navigation of elements and attributes. One key characteristic of DOM parsing is that it is well-suited for applications that require random access to nodes, as developers can traverse the structure freely.

Usefulness: DOM parsing is beneficial because it allows the developer to modify the document, adding or deleting nodes as required.
Consideration: However, it does require more memory since the whole document is loaded at once. This can become an issue with large XML files.
Example: When handling small to medium-sized XML files, DOM parsing is a solid choice due to its straightforward API and flexibility.

SAX Parsing

SAX (Simple API for XML) Parsing takes a different approach by reading the XML document in a sequential manner. Instead of loading the entire file into memory, SAX parsing generates events as it encounters different elements and attributes. This makes it a memory-efficient method.

Key Trait: SAX is a popular choice because it processes large XML files swiftly without the need for significant memory allocation.
Limitation: The downside is that it does not allow for modifications to the XML, as you can only read the data.
When to Use: This method is excellent for applications where the XML is too large to fit into memory, and only sequential reading is required.

StAX Parsing

StAX (Streaming API for XML) Parsing combines aspects of both DOM and SAX. It allows the developer to pull events as needed rather than having to handle everything sequentially. This gives developers more control over the parsing process.

Feature Highlight: The key characteristic of StAX is that it provides a user-friendly API for handling XML, accommodating both small and large documents efficiently.
Strengths and Weaknesses: While it uses less memory than DOM and provides more flexibility than SAX, it may require a steeper learning curve to get started.
Best Use Cases: StAX is suitable for applications requiring efficient parsing along with some flexibility to read or navigate through XML in a more controlled manner.

Understanding these XML parsing techniques equips developers to select the right method for their specific needs, enhancing their overall productivity in data handling and management.

Usage in Various Programming Languages

XML has become a cornerstone for data interchange across various programming environments. It delivers a standardized format, ensuring that different systems can communicate effectively. Understanding how XML is utilized in programming languages—like Java, C, and Python—provides insight into its versatility and practicality in real-world applications.

in Java

Java, often relied upon for enterprise-level applications, supports XML through libraries that make parsing, reading, and writing documents straightforward. Two prominent libraries widely used are DOM (Document Object Model) and SAX (Simple API for XML). DOM allows for loading the entire document into memory as a tree structure, enabling easy navigation and manipulation. SAX, on the other hand, reads the document sequentially, which can be more memory efficient for large files.

With tools like JAXP (Java API for XML Processing), developers can handle XML parsing seamlessly. Java’s strong integration with XML makes it suitable for creating complex web services that use XML-based messaging formats. This shows Java’s commitment to portability and platform independence, essential in today’s diverse technological landscapes.

in

While C doesn’t have built-in support for XML, several libraries fill this gap effectively. Expat and Libxml2 are examples of libraries that simplify the process of reading and writing XML documents. Expat is a fast and efficient XML parser designed for use in C and C++ programs. It’s well-known for its low memory footprint, making it suitable for embedded systems where resources are limited.

Using XML in C can introduce certain nuances, such as managing memory and handling pointers safely. Additionally, developers can utilize XML for configuration files to enhance application flexibility. This means you can change the software's behavior without recompiling the code—an attractive feature for maintainability.

in Python

Python offers a few robust libraries for handling XML, such as ElementTree and lxml. These libraries provide support for both reading and writing XML in user-friendly ways. ElementTree is part of the standard library, making it easily accessible without the need for additional installations. Its intuitive API allows developers to navigate XML structures effortlessly.

The simplicity of XML handling in Python extends to its use in web applications and APIs. Libraries such as Flask and Django often utilize XML for configurations and API responses. Additionally, error handling in Python with XML documents can be quite streamlined, thanks to built-in exceptions that describe the nature of the issue, enhancing debugging efforts.

Overall, across all these languages, the approach to XML may vary, but its foundational benefits—extensibility, human readability, and structured data representation—remains constant.

"Understanding XML use in different environments broadens a programmer’s toolbox, making them adaptable to various project needs."

By mastering XML across different programming languages, developers gain a competitive edge in creating applications that are data-driven and interoperable. The advantages of XML, when harnessed properly, lead to more efficient coding practices and enhanced application functionality.

Best Practices for Management

Efficient XML management is crucial for maintaining organized and effective data storage or transmission. When done right, it not only streamlines your workflow but also significantly improves the performance and reliability of any applications relying on XML data. In this section, we delve deep into the best practices that one should implement when managing XML documents, highlighting their benefits and offering practical insights.

Keeping Efficient

Real-world applications of XML in various programming environments

Efficiency in XML doesn't just mean compactness; it involves a careful balance between readability and performance. Here’s how to ensure your XML documents are efficient:

Minimize Redundancy: Avoid repetitive elements that can clutter your XML. If certain pieces of information are shared among multiple elements, consider referencing them instead.
Use Simple Types: Stick to the simplest data types necessary for your content. For example, if you only need a number, don’t use text format when integers would suffice.
Limit Nesting: Deeply nested structures can complicate parsing and make documents harder to read. Keep your hierarchy shallow wherever possible.
Trim Whitespace and Comments: While comments are helpful for documentation, excessive whitespace and lengthy comments can bloat your XML file size. Be concise and only include information that is absolutely necessary.

Adhering to these practices ensures that your XML documents remain lightweight and high-performing, which can be pivotal when dealing with large datasets.

Version Control and

Managing changes in XML documents often requires a solid version control system. Here’s why version control is essential, particularly in collaborative environments:

Track Changes: As files evolve, maintaining a record of changes becomes vital. Version control allows you to track modifications, so you can easily revert to previous versions if something goes south.
Collaboration: In team environments, differing approaches or styles can clash. A version control system, like Git, helps manage contributions, ensuring that everyone is on the same page.
File Integrity: Regularly saving checkpoints can safeguard against data loss due to corrupt files or accidental deletions. This aspect is particularly critical for large XML documents that undergo frequent revisions.

To implement effective version control, consider the following:

Choose a system: Popular options like Git or Mercurial serve well for XML files and can handle collaborative changes gracefully.
Establish a branching model: Ensure every new feature or fix is developed in a separate branch. Merging efforts later help keep the main document clean.
Use meaningful commit messages: Explain why a change was made when you commit new changes. This practice saves time when reviewing the history of alterations.

By adopting these version control practices, you not only enhance the organization of your XML documents but also promote better teamwork and prevent mishaps during development.

"Efficient XML management lowers the barriers to effective data exchange, making your workflow sleeker and less prone to errors."

In summary, mastering XML management encompasses both efficiency and meticulous version control. By implementing these best practices, you’ll not only ease the load of XML document handling but also set the stage for scalable, robust applications.

Troubleshooting Common Issues

In the realm of XML document creation, troubleshooting common issues is an essential skill. Why? Because even the most seasoned developers may encounter hurdles that come from syntax errors or validation failures. Addressing these common pitfalls not only boosts the efficiency of your workflow but also helps ensure that the XML data representation is accurate and functional. Let’s dive into the specifics of identifying syntax erros and handling validation failures. Having a grasp of these concepts can save you from potential headaches down the road.

Identifying Syntax Errors

A syntax error in an XML document is like a flat tire on a road trip: it can bring everything to a halt. These errors can occur for a myriad of reasons, often leading to frustration if not addressed efficiently. Common syntax errors include:

Mismatched Tags: Each opening tag must have a corresponding closing tag. For example, must be followed by . If you forget to close one, it can throw the whole structure off.
Improper Nesting: Tags should be properly nested within each other. Using the earlier example, you can’t have an incorrectly nested structure like this: . It can result in parsing errors.
Missing Declaration: Starting your XML with the correct declaration is key. Without the declaration at the top, parsers might misinterpret the entire document.

To identify syntax errors, it's beneficial to use XML validators or parsers that can flag problems before deployment. The online resources such as W3Schools XML Validator can come in handy. It’s like having a trusty sidekick to catch the mistakes you may overlook.

"An ounce of prevention is worth a pound of cure." – Benjamin Franklin. In this case, ensuring your XML is clean and well-formed can save you hours of debugging.

Handling Validation Failures

Once you've tackled syntax errors, the next barrier often faced lies in validation failures. These failures usually arise during the validation process where your XML does not conform to a specific structure defined by a DTD or XML Schema. Understanding how to handle these failures is crucial for maintaining data integrity.

Validation failures may stem from:

Type Mismatches: If a particular field expects a number but encounters a string. For example, a field expecting may fail if it reads .
Structural anomolies: Similar to syntax errors but on a higher level. If mandatory elements are missing, or elements appear in the wrong order, the document won't validate.
Default Values and Enumerations: If an element has a constraint that allows only certain values (like in XML Schema) and your document doesn’t comply, it’ll fail validation.

To address these issues, it’s best to conduct regular checks against your XML design, using tools like XMLSpy or Oxygen XML Editor, which help enforce rules during document creation. Fine-tuning your XML document before deployment can save considerable time and can lead to smoother implementations.

and Web Development

XML plays a crucial role in the landscape of web development, acting as a bridge between different systems, data, and applications. Understanding its importance aids developers, especially those who are venturing into creating robust and scalable applications. One major advantage of XML in web development is its flexibility for data representation. Unlike traditional databases that often output data in rigid formats, XML allows for hierarchical structuring, which can effectively mirror complex data sets and relationships.

When considering the use of XML in web applications, it’s vital to recognize its capability to interoperate with APIs, facilitating seamless data exchange between different services. This feature makes it a viable choice for both frontend and backend development. By utilizing XML, developers can ensure that the APIs are not only easy to consume but also adaptable to various data types, thereby ensuring higher efficiency and utility.

This adaptability is particularly significant as APIs increase in complexity. Using XML with APIs presents a host of advantages such as:

Cross-Platform Compatibility: XML can be read and written by different programming languages, making it an ideal choice for diverse systems.
Self-Descriptiveness: The data is organized in a way that its structure is evident, allowing machines and humans alike to understand it more readily.
Ease of Updating: As projects grow, keeping track of data formats can be a headache. XML simplifies this by allowing for straightforward updates to the document structure.

"When designing web applications, embracing XML can unlock opportunities for more flexible data handling and meaningful user experiences."

Another interesting aspect to consider is how XML fits into the realm of web services. This is crucial as it underpins many modern web applications which depend heavily on data interchange. XML in Web Services showcases:

Interoperability: XML web services enable diverse applications from various vendors to share data effortlessly, regardless of the underlying technology.
Document-centric Communication: XML's ability to encapsulate both data and its metadata makes it particularly useful for document-centric communications where clarity and structure are paramount.
Protocol Agnosticism: Web services can utilize various protocols, such as SOAP (Simple Object Access Protocol) and REST (Representational State Transfer), all of which can leverage XML for their messaging format.

The Future of

As we venture into the evolving landscape of data interchange formats, it becomes essential to scrutinize the role of XML. While other formats have captured the limelight, XML persists, providing significant value, particularly in data representation and transfer. Its future is woven with both challenges and opportunities that merit attention.

One of the primary reasons XML remains relevant is its fundamental versatility. Wherever structured data is necessary, XML likely plays a role. This adaptability positions it as a backbone for many applications, from information exchange processes to complex web services. As data flows across various platforms, XML ensures that the structure is preserved, allowing for seamless communication.

Trends in Data Representation

In recent times, the arena of data representation has shifted quite dramatically. JSON has emerged as a fierce competitor to XML, favored for its simplicity and smaller payload size. However, XML isn't simply rolling over; it has been adapting to meet modern needs.

Hierarchical Data Representation: XML's ability to create a clear hierarchy and depict relationships among data entities is unmatched. This makes it invaluable when the nature of the data is complex and demands a well-defined structure.
Metadata Inclusion: XML facilitates the inclusion of rich metadata, enriching the data it describes. This trait has found its place in applications where data context is as important as the data itself, like in publishing and archiving contexts.
Interoperability Enhancements: XML is particularly strong in environments where systems must communicate across diverse platforms, whether they are running different operating systems or programming languages. Its capacity for preserving the structure can minimize data loss, a crucial factor in today's integrated application environments.

"XML's legacy is not just about surviving; it’s about evolving to meet new challenges in the data landscape."

Alternatives to

As we look ahead, alternatives are continuing to gain traction. JSON, Protocol Buffers, and YAML are not only providing simpler ways to represent data but also adding unique advantages that XML must address.

JSON: Quick to parse and lightweight, JSON shines in web applications where speed is paramount. It’s particularly suited for lightweight data exchange in AJAX applications.
Protocol Buffers: Developed by Google, they compress data into a binary format that enhances speed and reduces bandwidth, guarding against the bloated payloads common with XML.
YAML: Known for its human-readable format, YAML is often favored in configuration files and data exchange, thanks to its clean syntax.

Despite these emerging alternatives, XML hasn’t lost its appeal. Its mature ecosystem of parsers and validators remains a significant advantage. Additionally, XML Schemas continue to provide rich validation options that many alternatives lack. The choice between these formats will often depend on the specific needs of a project; XML still holds a formidable position in its capacity to handle complex structured data scenarios.

Have More Great Articles: