Internal Documentation Made Easy: Git for Knowledge Management

Welcome to Git and Version Control Hub!
Are you ready to unlock a surprisingly powerful secret weapon for managing your internal documentation? Dive into our latest article, "Internal Documentation Made Easy: Git for Knowledge Management", and discover how to leverage Git for knowledge management tools. It's more than just code; it's about streamlined workflows, collaborative environments, and a whole new level of control over your valuable information. Intrigued? Let's explore how version control can revolutionize your team's knowledge base!
- Why Use Git for Managing Your Internal Documentation?
- Setting Up a Git Repository for Internal Documentation
- Workflow Examples: Git-Based Documentation Management
- Integrating Git with Documentation Tools
- Best Practices for Using Git in Knowledge Management Systems
- Git for Documentation: Addressing Common Challenges
- Conclusion: Streamlining Knowledge Management with Git Version Control
-
Frequently Asked Questions
- How can Git be used for internal documentation?
- What are the benefits of using Git for knowledge management over traditional methods?
- How does Git facilitate collaboration on internal documentation?
- Can Git integrate with existing knowledge management platforms?
- What Git commands are most useful for managing internal documentation?
- Final Reflection: Embracing Git as a Knowledge Sanctuary
- Embrace Git for Effortless Knowledge Sharing!
Why Use Git for Managing Your Internal Documentation?
Version Control Advantages for Documentation Teams
Version control systems, like Git, offer significant advantages for documentation teams, mirroring their benefits in software development. One of the primary advantages is the ability to track every change made to documentation over time. This means documentation teams can easily revert to previous versions if errors are introduced or if a prior state of the documentation is needed for reference.
Imagine a scenario where a technical writer accidentally deletes a critical section of a user manual. With Git, they can quickly restore the previous version, minimizing disruption and preventing data loss. This capability is crucial for maintaining the integrity and reliability of internal knowledge bases, especially in fast-paced environments where documentation is frequently updated.
Beyond simple rollback, version control provides a detailed history of modifications. Each change, or "commit" in Git terminology, is accompanied by a message explaining the update. This creates a comprehensive audit trail, allowing teams to understand the evolution of the documentation, identify who made specific changes, and why.
For example, if there's a question about why a particular procedure was modified, the team can examine the commit history to find the rationale behind the change, often directly from the author's commit message. This level of transparency and accountability is invaluable for collaborative documentation efforts and ensures that knowledge is not only managed but also understood within its historical context.
Git's Branching Model for Documentation Updates
Git's branching model is a powerful feature that significantly streamlines documentation updates, especially when multiple writers are involved or when working on complex revisions. Branching allows documentation teams to create isolated environments to work on new features, updates, or corrections without directly affecting the main documentation. Consider a situation where a team is preparing documentation for a major product release while simultaneously needing to update existing documentation for minor patches. With Git, they can create separate branches for each task β perhaps a release-v2.0 branch for the new release documentation and a hotfix-1.1 branch for the patch updates. This isolation prevents conflicts and ensures that work on different aspects of the documentation can proceed in parallel.
Once updates are completed and reviewed on a branch, Git facilitates merging these changes back into the main documentation branch, often called main or master. This merge process integrates the new content seamlessly with the existing documentation. Furthermore, Git's branching model supports feature-based development in documentation. For instance, a writer working on a new section about API integrations could create a dedicated branch named feature/api-integration. This focused approach allows for incremental development and review of specific documentation components before they are integrated into the larger body of documentation, promoting better organization and reducing the risk of introducing errors during major updates.
Collaboration and Review Processes with Git in Documentation
Git fundamentally enhances collaboration and review processes within documentation teams. Its distributed nature allows multiple writers to work on the same documentation concurrently without overwriting each other's changes. Using platforms like GitHub or GitLab, teams can leverage features like pull requests (or merge requests in GitLab) to implement a structured review workflow.
Imagine a technical writer completes a draft of a new tutorial. Instead of emailing a document back and forth, they create a pull request, effectively proposing their changes to the main documentation. Other team members can then review the proposed changes directly within the Git platform, adding comments, suggesting edits, and having discussions inline with the documentation content.
This collaborative review process significantly improves the quality and accuracy of documentation. Reviewers can easily see exactly what changes have been made, providing targeted feedback. Furthermore, Git platforms often integrate with notification systems, ensuring that relevant team members are alerted to new pull requests or comments, streamlining the review cycle. This structured approach not only facilitates better documentation but also fosters a more collaborative and transparent team environment. The ability to track discussions and decisions directly alongside the documentation itself provides a valuable context for future updates and revisions.
Git for Documentation: Audit Trails and Accountability
Employing Git for documentation provides robust audit trails and enhances accountability within documentation workflows. Every change made to the documentation is meticulously recorded, including who made the change, when, and what modifications were implemented. This detailed history serves as an invaluable audit trail, allowing teams to track the evolution of their knowledge base and understand the rationale behind specific documentation decisions. For example, if a compliance audit requires a history of policy documentation updates, Git provides a readily accessible and verifiable record of all changes, complete with timestamps and author information.
Beyond compliance, this audit trail fosters greater accountability among documentation contributors. Because every change is attributed to a specific individual, there is increased ownership and responsibility for the accuracy and quality of the documentation. If inaccuracies or inconsistencies are discovered, it's straightforward to trace back to the commit that introduced the issue and engage with the author for clarification or correction.
This level of accountability is particularly important in regulated industries or organizations where documentation accuracy and traceability are paramount. Git's inherent tracking capabilities not only simplify auditing processes but also promote a culture of responsibility and continuous improvement within documentation teams.
Setting Up a Git Repository for Internal Documentation
Choosing the Right Repository Structure for Documentation
Selecting the appropriate repository structure is a crucial first step when using Git for managing internal documentation. There are several common approaches, each with its own advantages depending on the scale and complexity of the documentation project. One common structure is to have a single repository for all internal documentation.
This centralized approach simplifies management, especially for smaller organizations or when documentation is closely related across different areas. For instance, a small startup might store all its employee handbooks, process documentation, and technical guides within a single Git repository, making it easy to search and maintain consistency across all documentation.
Alternatively, for larger organizations or projects with distinct documentation sets, a multi-repository approach might be more suitable. This involves creating separate repositories for different types of documentation β for example, one repository for API documentation, another for user manuals, and another for internal knowledge base articles. This modular approach can improve organization and access control, particularly when different teams are responsible for different documentation areas.
For example, the engineering team might manage the API documentation repository, while the customer support team manages the user manual repository. Careful consideration of the documentation's scope, team structure, and access requirements is essential to choose the repository structure that best supports efficient management and collaboration.
Initializing a Git Repository for Documentation Projects
Initializing a Git repository for documentation projects is a straightforward process. It begins by navigating to the root directory where the documentation files will be stored using the command line. Once in the correct directory, the command git init is executed. This command creates a hidden .git subdirectory, which contains all the necessary repository metadata and object database. This action effectively transforms the directory into a Git repository, ready to track changes. For example, if the documentation is located in a folder named internal-docs, you would navigate into this folder in your terminal and run git init.
After initialization, the next step is to add the documentation files to the repository. This is done using the git add command. To add all files in the current directory and its subdirectories, the command git add . is used. Alternatively, specific files can be added individually, such as git add user-manual.md or git add api-reference.txt. Finally, the initial state of the documentation is committed to the repository using the git commit command. A descriptive commit message is crucial at this stage to explain the initial content. For instance, git commit -m "Initial commit: Import existing internal documentation". This initial commit establishes the baseline version of the documentation within the Git repository, and subsequent changes will be tracked relative to this starting point.
Configuring .gitignore for Documentation Files
Properly configuring the .gitignore file is essential for maintaining a clean and efficient Git repository for documentation. The .gitignore file specifies intentionally untracked files that Git should ignore. This is particularly important in documentation projects where there might be temporary files, build artifacts, or sensitive information that should not be version controlled. For example, documentation projects often use build tools that generate output files like HTML or PDF versions of the documentation. These generated files should typically be excluded from version control as they can be regenerated from the source documentation files. Adding entries like build/ or *.pdf to the .gitignore file will prevent Git from tracking these files.
Furthermore, .gitignore can be used to exclude temporary editor files (e.g., *.swp for Vim, .~ for Emacs), operating system specific files (e.g., .DS_Store on macOS), or any files containing sensitive information that should not be committed to the repository. For instance, if configuration files containing API keys are present in the documentation directory, they should be explicitly added to .gitignore to prevent accidental commits. A well-configured .gitignore file keeps the repository focused on the source documentation files, reduces clutter, and prevents accidental inclusion of unwanted or sensitive data in the version history.
Workflow Examples: Git-Based Documentation Management
Basic Workflow: Committing and Pushing Documentation Changes
The basic workflow for managing documentation with Git revolves around the concepts of committing changes locally and pushing them to a remote repository. After making modifications to documentation files, the first step is to stage these changes using the git add command. This command prepares the modified files to be included in the next commit. For example, after updating a section in user-guide.md, you would run git add user-guide.md. Next, the staged changes are committed using the git commit command. A clear and concise commit message is crucial, summarizing the changes made. For instance, git commit -m "Fix: Corrected steps for user onboarding process in user guide". This commit records the changes in the local repository history.
To share these changes with collaborators and back them up to a remote server, the git push command is used. This command uploads the local commits to a remote repository, such as one hosted on GitHub, GitLab, or Bitbucket. Typically, the command would be git push origin main, assuming origin is the name of the remote repository and main is the branch to which changes are being pushed. This push operation ensures that the latest documentation changes are available to the entire team and are safely stored in the remote repository. This commit-push cycle forms the fundamental workflow for managing documentation updates using Git, providing a structured and version-controlled approach.
Branching and Merging for Documentation Updates
Branching and merging are central to managing more complex documentation updates and collaborative efforts using Git. When starting work on a new feature, a significant revision, or a bug fix in the documentation, it's best practice to create a new branch. This isolates the changes and prevents them from directly affecting the main documentation branch until they are ready. To create a new branch named update-api-section, you would use the command git checkout -b update-api-section. This command creates and switches to the new branch. Work on the documentation is then performed within this branch, committing changes as needed.
Once the work on the branch is complete and reviewed, the changes need to be integrated back into the main documentation branch. This is achieved through a merge process. First, switch back to the main branch using git checkout main. Then, merge the feature branch into the main branch using git merge update-api-section. This command integrates the changes from the update-api-section branch into the main branch. In collaborative environments, this merge is often performed via a pull request, allowing for code review and discussion before integration. Branching and merging enable parallel development, feature isolation, and a controlled integration process for documentation updates, crucial for larger teams and complex documentation projects.
Tagging Documentation Releases with Git
Tagging in Git is a useful feature for marking specific points in the documentation history as releases. This is particularly valuable for versioned documentation, allowing teams to easily refer back to documentation corresponding to specific software versions or release cycles. To create a tag, the git tag command is used. For example, to tag the current state of the documentation as version 1.0, the command would be git tag v1.0. Tags are typically annotated, meaning they include a message. To create an annotated tag, use git tag -a v1.0 -m "Release version 1.0 documentation". This creates a tag named v1.0 with a descriptive message.
Tags are pointers to specific commits, effectively creating snapshots of the documentation at a particular point in time. After creating a tag locally, it needs to be pushed to the remote repository to be shared with others. This is done using git push origin --tags. Once pushed, tags are visible to all collaborators and can be used to easily checkout the documentation at that specific release point. For instance, to view the documentation as it was at version 1.0, you could checkout the tag using git checkout tags/v1.0. Tagging provides a clear and persistent way to manage and reference documentation releases, essential for maintaining version control and providing users with documentation that accurately reflects their software version.
Integrating Git with Documentation Tools
Git and Markdown: A Powerful Combination for Documentation
The combination of Git and Markdown is exceptionally powerful for documentation management. Markdown is a lightweight markup language that is easy to read and write, making it ideal for authoring documentation. Its simplicity allows writers to focus on content creation without being bogged down by complex formatting syntax. Git, in turn, provides robust version control for these Markdown files. Because Markdown files are plain text, Git can efficiently track changes, manage versions, and facilitate collaboration on documentation projects written in Markdown. This synergy makes Markdown and Git a popular choice for documenting software projects, APIs, and internal knowledge bases.
Many popular documentation tools and platforms natively support Markdown, further enhancing this combination. For instance, platforms like GitHub, GitLab, and Bitbucket render Markdown files directly in repositories, making it easy to view documentation directly online. Static site generators, like Jekyll and Hugo, are also often used with Markdown and Git to build and deploy documentation websites.
This ecosystem of tools and technologies built around Markdown and Git provides a streamlined and efficient workflow for creating, managing, and publishing high-quality documentation. The plain text nature of Markdown also makes it highly portable and future-proof, ensuring long-term accessibility and maintainability of documentation stored in Git repositories.
Using Static Site Generators with Git for Documentation Deployment
Static site generators (SSGs) like Jekyll, Hugo, and Gatsby seamlessly integrate with Git to streamline documentation deployment. SSGs take Markdown (or other markup languages) content, apply templates, and generate static HTML websites. When used in conjunction with Git, the documentation source files (Markdown files, configuration, templates) are stored in a Git repository.
Changes to the documentation are made by modifying these source files and committing them to the Git repository. Upon pushing these changes, automated systems (like CI/CD pipelines or webhooks) can trigger the SSG to rebuild the documentation website and deploy the updated static files to a web server.
This workflow offers several advantages. Firstly, it leverages Git for version control of the documentation source, ensuring a complete history of changes and facilitating collaboration. Secondly, SSGs generate static websites, which are inherently fast, secure, and easy to host. Thirdly, the deployment process can be automated, ensuring that documentation updates are quickly and consistently published whenever changes are pushed to the Git repository. For example, a team might use GitHub Actions to automatically rebuild and deploy their documentation website hosted on Netlify every time changes are pushed to the main branch of their documentation repository. This combination of Git and SSGs provides a robust, scalable, and efficient solution for documentation management and deployment.
Integrating Git with Read the Docs
Read the Docs (RTD) is a popular platform specifically designed for hosting documentation, and it integrates tightly with Git repositories. RTD automatically builds documentation from Git repositories whenever changes are pushed. It supports various documentation formats, including Sphinx, MkDocs, and other static site generators.
To use RTD with Git, you simply connect your Git repository (hosted on platforms like GitHub, GitLab, or Bitbucket) to your Read the Docs project. RTD then monitors the repository for changes. Whenever a new commit is pushed, RTD automatically fetches the latest version of the repository, builds the documentation using the configured documentation tool (e.g., Sphinx), and updates the hosted documentation website.
This integration greatly simplifies the documentation deployment process. Documentation teams no longer need to manually build and deploy their documentation after each update. RTD handles this automatically, ensuring that the online documentation is always up-to-date with the latest changes in the Git repository.
Furthermore, RTD provides features like versioning, allowing users to access documentation for different versions or branches of the software project. This integration between Git and Read the Docs creates a seamless and automated documentation workflow, from authoring and version control in Git to building and hosting on Read the Docs, making it a highly efficient solution for software documentation.
Best Practices for Using Git in Knowledge Management Systems
Clear Commit Messages for Effective Documentation History
Writing clear and informative commit messages is paramount when using Git for knowledge management. Commit messages serve as the historical record of changes made to the documentation, and well-written messages are crucial for understanding the evolution of the knowledge base. Each commit message should concisely summarize the changes introduced in that commit and, ideally, explain the rationale behind those changes. Instead of vague messages like "Update documentation," a better commit message would be "Fix: Clarify steps for password reset process in user manual" or "Feat: Add section on API authentication methods to developer guide."
Effective commit messages follow established conventions, often starting with a type (e.g., Fix, Feat, Docs, Refactor) followed by a concise summary. This structure improves readability and allows for easier filtering and analysis of the commit history. For example, using prefixes like "Fix:" for bug fixes, "Feat:" for new features, and "Docs:" for documentation-specific changes helps quickly categorize commits.
Investing time in crafting clear commit messages pays off significantly in the long run by making it easier to understand the history of documentation changes, troubleshoot issues, and collaborate effectively. A well-maintained commit history acts as a valuable resource for the entire team and future documentation maintainers.
Consistent Branching Strategies for Documentation
Adopting a consistent branching strategy is essential for managing documentation effectively with Git, especially in collaborative environments. A branching strategy defines how branches are used for different types of work and how changes are integrated. One popular strategy is Gitflow, which defines branches like main for stable releases, develop for ongoing development, and feature branches for specific features or updates. For documentation, a simplified approach might suffice, such as using main for the live documentation and feature branches for new documentation sections or major revisions.
Regardless of the specific strategy chosen, consistency is key. Teams should agree on a branching strategy and adhere to it rigorously. This ensures that everyone understands the purpose of different branches and how to contribute changes correctly. For example, if the team decides to use feature branches for all documentation updates, then every writer should create a new branch for each update and merge it back to main via a pull request. Consistent branching strategies minimize confusion, prevent conflicts, and streamline the documentation workflow, especially as the documentation project grows and involves more contributors. Regularly reviewing and refining the branching strategy as needed ensures its continued effectiveness as the project evolves.
Reviewing Documentation Changes Before Merging
Implementing a review process for documentation changes before merging them into the main branch is a best practice that significantly enhances documentation quality and accuracy. Just as code changes undergo review, documentation updates should also be reviewed by peers or subject matter experts. This review process helps catch errors, inconsistencies, and areas for improvement before the changes are published. Using pull requests (or merge requests) in Git platforms like GitHub or GitLab is an effective way to facilitate documentation reviews.
When a writer completes a documentation update on a feature branch, they create a pull request to merge their changes into the main branch. This pull request serves as a formal request for review. Designated reviewers are notified and can then examine the proposed changes directly within the Git platform. Reviewers can provide feedback, suggest edits, and ask questions inline with the documentation content.
The writer can then address the feedback and update the documentation accordingly. Only after the reviewers approve the pull request are the changes merged into the main branch. This review process ensures that documentation is accurate, clear, and consistent, ultimately improving the quality and usability of the knowledge base.
Automating Documentation Builds and Deployments with Git Hooks
Automating documentation builds and deployments using Git hooks can significantly streamline the documentation workflow and ensure timely updates. Git hooks are scripts that Git executes automatically before or after events such as commits, pushes, and merges. For documentation projects, hooks can be used to automate tasks like building the documentation website after each commit or deploying the updated documentation to a web server after a merge to the main branch. For instance, a post-commit hook could be configured to automatically rebuild the documentation locally after each commit, allowing writers to quickly preview their changes.
More importantly, post-receive hooks on a remote server can be used to automate deployment. When changes are pushed to the remote repository, the post-receive hook can trigger a build process and deploy the updated documentation to a staging or production environment. This automation eliminates manual build and deployment steps, reduces the risk of errors, and ensures that documentation updates are published promptly. For example, a post-receive hook could trigger a static site generator to rebuild the website and then use rsync to deploy the static files to a web server. Automating these processes with Git hooks makes the documentation workflow more efficient, reliable, and less prone to manual errors.
Git for Documentation: Addressing Common Challenges
Handling Large Documentation Files in Git
Handling large documentation files in Git requires specific strategies to maintain repository performance and efficiency. Git is optimized for tracking changes in text-based files, and while it can handle binary files, large files can lead to repository bloat and slower operations. For documentation projects that include large binary files such as high-resolution images, videos, or PDFs, Git Large File Storage (LFS) is a valuable extension. Git LFS replaces large files in the repository with text pointers, storing the actual file content separately. This keeps the repository size manageable and improves performance, especially for cloning and fetching operations.
When using Git LFS, large files are tracked by LFS, while text-based documentation files are tracked by Git directly. To use Git LFS, it needs to be initialized in the repository using git lfs install. Then, file patterns for large files need to be specified using git lfs track "*.pdf" or git lfs track "images/*.png". After tracking, when these large files are added and committed, Git LFS will handle their storage efficiently. For very large repositories or those with extremely large binary assets, alternative strategies like separating large assets into separate storage solutions and linking to them from the documentation might also be considered. However, Git LFS provides a convenient and integrated solution for managing large files within a Git repository for most documentation scenarios.
Resolving Merge Conflicts in Documentation
Merge conflicts can arise in Git when multiple writers make concurrent changes to the same documentation files, particularly when working on the same lines or sections. Git is generally good at automatically merging changes, but conflicts occur when Git cannot determine how to integrate conflicting modifications automatically. When a merge conflict occurs, Git marks the conflicting sections in the affected files with special markers ( <<<<<<<, =======, >>>>>>>). Resolving these conflicts requires manual intervention. The writer needs to open the conflicted file, examine the conflicting sections marked by Git, and decide how to reconcile the changes.
This typically involves choosing which changes to keep, modifying the content to incorporate both sets of changes, or reverting to one version. Once the conflicts are resolved, the conflict markers are removed, and the file is staged and committed to complete the merge. Clear communication and collaboration among documentation writers are crucial to minimize merge conflicts.
Breaking down large documentation updates into smaller, more manageable commits and feature branches can also help reduce the likelihood of conflicts. Regularly pulling changes from the remote repository and merging them into local branches can also help detect and resolve conflicts early in the development process, rather than encountering large, complex conflicts later on.
Securing Sensitive Information in Git Repositories
Securing sensitive information in Git repositories is paramount, especially when managing internal documentation that might contain confidential data, API keys, or internal credentials. Directly committing sensitive information into Git repositories is highly discouraged due to the risk of exposure in the repository history. Instead, sensitive information should be managed separately and securely, and only referenced or injected into the documentation build process at deployment time. Environment variables are a common and secure way to manage configuration settings, including sensitive information.
For example, API keys should be stored as environment variables rather than hardcoded in documentation files. Documentation build scripts can then access these environment variables during the build process and inject the necessary values into the documentation output. Tools like .env files (when used with caution and excluded from version control) or dedicated secret management services can help manage environment variables and sensitive configuration. Furthermore, access control mechanisms provided by Git hosting platforms (like GitHub or GitLab) should be configured to restrict access to the documentation repository to only authorized personnel. Regularly auditing repository access and reviewing commit history for accidental exposure of sensitive information are also crucial security practices.
Conclusion: Streamlining Knowledge Management with Git Version Control
Frequently Asked Questions
How can Git be used for internal documentation?
Git allows you to version control your documentation, enabling you to track changes, revert to previous versions, and collaborate with others on updates. This makes it easy to maintain a single source of truth for your internal knowledge base.
What are the benefits of using Git for knowledge management over traditional methods?
Git provides built-in version history, collaboration features, and the ability to easily compare different versions of documents. This is a significant improvement over traditional methods like shared drives, which lack these crucial version control capabilities.
How does Git facilitate collaboration on internal documentation?
Git enables multiple contributors to work on documentation simultaneously using branching and merging. This prevents conflicts and allows for a structured review process before changes are integrated into the main branch.
Can Git integrate with existing knowledge management platforms?
While Git itself isn't a knowledge management platform, its repositories can be easily integrated with tools that support Markdown or other text-based formats. This allows you to leverage Git's version control features within your existing workflow.
What Git commands are most useful for managing internal documentation?
Key commands include git commit (to save changes), git push (to upload changes), git pull (to download changes), git branch (to create branches), and git merge (to combine branches). Mastering these commands is essential for effective documentation management.
Final Reflection: Embracing Git as a Knowledge Sanctuary
The journey of exploring Git as a knowledge management tool reveals a powerful truth: information, like code, thrives on version control and collaboration. In today's fast-paced world, where information overload is the norm, the ability to track, share, and refine knowledge efficiently is not just beneficial, it's essential for organizational success and individual growth. Git offers a robust and surprisingly intuitive solution to this challenge, transforming how we approach internal documentation.
This shift towards Git-based knowledge management is already subtly reshaping the cultural landscape of many organizations. It fosters a culture of transparency, encourages active participation in knowledge creation, and empowers individuals to contribute their expertise. Knowledge is power. Information is liberating. Education is the premise of progress, in every society, in every family.
- Kofi Annan. This quote perfectly encapsulates the potential of Git to democratize knowledge within an organization, making it more accessible and empowering every member to contribute to its collective wisdom.
Now, as you close this article, consider how you can integrate these principles into your own workflow. How can you leverage the power of Git to create a more organized, collaborative, and accessible knowledge base? Embrace the potential of Git to transform your internal documentation, and you'll unlock a new era of efficiency, innovation, and shared understanding within your team and beyond.
Embrace Git for Effortless Knowledge Sharing!
Thanks for exploring how Git can revolutionize your internal documentation! We hope you've discovered how version control can bring clarity and structure to your knowledge base. Now, let's put that knowledge into action.
Ready to transform your team's documentation process? Here's how to get started:
- Begin by creating a dedicated Git repository for your team's documentation. Treat it like code: version, branch, and merge thoughtfully!
- Explore existing documentation solutions built on Git, such as MkDocs or similar platforms, to find one that suits your team's needs.
- Share this article with a colleague who struggles with documentation or internal knowledge sharing. You might just save them hours of frustration!
What Git command will you use today to improve your team's documentation? Let us know in the comments!
