Merge pull request #236 from intelops/chandu

Tanuja changes and Shreya's blog

.gitignore

@@ -17,4 +17,7 @@ resources/_gen/
 **/._.DS_Store
 yarn-error.log
 yarn.lock
-node_modules
+node_modules
+
+
+.forestry

content/english/blog/simplify-modern-application-development-with-auto-code-generator-compage/index.md

@@ -0,0 +1,98 @@
+---
+date: 2023-08-09
+title: Simplify Modern Application Development with Auto Code Generator Compage
+description: Overview blog for compage
+image: images/blog/simplify-modern-application-development-with-auto-code-generator-compage/modernappdevelopment_v1.jpg
+cover_image: false
+cover_image_src: 
+cover_image_height: ""
+cover_image_width: ""
+
+author: shreya
+series: Cloud Native Applications
+categories:
+- Software Supply chain security
+- Backend automation
+- Application development
+
+tags:
+- Open Api Generator 
+- Git Integration
+
+
+# image color code in undraw.co #FB7E44
+feedback: false
+draft: false
+
+---
+<!-- assets\images\blog\simplify-modern-application-development-with-auto-code-generator-compage\modernappdevelopment_v1.jpg -->
+{{< image src="/images/blog/simplify-modern-application-development-with-auto-code-generator-compage/modernappdevelopment_v1.jpg" alt="alter-text" height="" width="200px" class="img-fluid" caption="" webp="false" position="float-left" >}}
+
+Efficiency and speed are vital for success in software development. Traditional manual coding is slow, error-prone, and lacks consistency. Addressing this challenge demands the adoption of an innovative approach that facilitates development teams from the start, by streamlining the backend development process.
+
+And that's exactly what Compage does. The open-source project [automates backend code generation](https://intelops.ai/compage/) based on diagram-based (diagram-to-code) requirements, increasing productivity, reducing development time, and improving consistency throughout the development lifecycle. Not just that, Compage also follows securing coding measures by automating the software supply chain security process (more below).
+
+## Diagram-based Requirements
+
+Compage’s solution architecture utilizes diagram-based requirements to generate models that represent the proposed system, its components and interactions. The information provided serves as a guide for generating the backend code, aligning with the captured requirements and design. Compage’s diagram-based approach simplifies the development process by providing a clear and intuitive way to conceptualize the system’s structure and behavior, enabling effective communication of complex ideas and relationships.
+
+Below is a quick example of how you can generate code in Compage using diagram-based requirements:
+
+1. Log into Compage with GitHub.
+<img src="./images/compage-login.png" />
+2. Create a new project.
+<img src="./images/compage-project.png" />
+3. Create a node and add the node properties details.
+<img src="./images/compage-node-properties.png" />
+4. The node is generated in the language of your choice. (We selected Go to show this example)
+<img src="./images/compage-node-with-code.png" />
+5. Once the code is generated, the node is updated with the component name given at the time of its creation.
+<img src="./images/compage-update-node.png" />
+6. Save any changes to make and then click on **Generate Code**. Developers running multiple projects on Compage can easily switch between them using the **Switch Project** option.
+<img src="./images/compage-generate-code.png" />
+
+The solution architecture offers CRUD operations for efficient data management and seamlessly integrates with OpenTelemetry for comprehensive monitoring and tracing of system behavior.
+
+## Maintaining a Cohesive Codebase
+
+The easy-to-use solution architecture provides a structured approach that eliminates the need for extensive manual coding and guides developers through the input process, reducing the likelihood of errors or omissions. Compage promotes standardized inputs to ensure consistency throughout the development process. It enforces predefined patterns and conventions, prompting developers to adhere to best practices and maintain a cohesive codebase. This consistency improves code quality and simplifies future maintenance and enhancements.
+
+## Promoting Team Collaboration
+
+Another advantage is the enhanced collaboration among team members. The standardized inputs facilitate better communication and alignment across the development team. They serve as a common language for expressing the desired backend configurations, eliminating misunderstandings and promoting a shared understanding of the system’s requirements.
+
+## Automated Code Generation
+
+Once diagram-based requirements are created and inputs are captured, developers can initiate the code generation process with Compage. The tool analyzes the provided information and generates backend code in the desired programming language, such as Java, Python, JavaScript, Go lang, Rust, Bun, Carbon, etc.
+
+Automating the code generation process offers several benefits:
+
+- Minimizing Human Errors
+- Boosting Development Speed and Efficiency
+- Fostering Consistency in Backend Development
+
+By leveraging automated code generation, developers can shift their focus to higher-level tasks, enabling them to deliver resilient, standardized, and efficient backend systems.
+
+## Deployment & Testing
+
+Compage offers easy integration with testing and deployment workflows, ensuring the effective deployment and integrity of the backend system. Continuous integration is a crucial step, where changes to the codebase are regularly integrated, tested, and validated. It involves automatically building the code, running unit tests, and checking for potential issues.
+
+Once the code has passed the continuous integration phase, Compage supports deploying the generated code to different environments, such as development, staging, and production. Automated tests can be consistently and repeatedly executed, ensuring that the system behaves as expected across various environments. Automated deployment significantly reduces the manual effort required for deployment tasks, saving time and minimizing the risk of configuration errors.
+
+## Git platform(s) Integration
+
+Compage is an open-source project that seamlessly integrates with Git platforms to provide efficient version control and collaboration capabilities for the code generation process. Using Git repositories, developers can track changes, manage branches and collaborate with team members. We encourage developers to [contribute to the project](https://docs.intelops.ai/1.0.1/compage/6-contribution/) to help us further enhance its capabilities and expand its features.
+
+## OpenAPI Generator Support
+
+Compage leverages OpenAPI specifications to generate backend code and REST servers in popular programming languages like Go, Java, JavaScript, Python, and Ruby. OpenAPI supports a wide range of programming languages and frameworks, making it versatile and compatible with various backend development scenarios. This enables developers to align the generated code with their preferred coding style and project conventions, ensuring seamless integration into the existing codebase while adhering to established coding guidelines.
+
+First-of-its-kind, Compage revolutionizes software and application development, empowering developers with increased productivity and improved consistency. Its seamless integration for deployment, Git version control, Observability Instrumentation and OpenAPI Generator support help deliver efficient, standardized, and resilient backend systems.
+
+## Software Supply Chain Security
+
+Compage employs several measures to enhance software supply chain security for secure code delivery. These include code signing for code integrity and immutable ledger logs in SDLC for traceability and accountability. Compage utilizes SBOM to provide clarity on components and dependencies and generates comprehensive vulnerability reports, aiding proactive identification and mitigation. The solution streamlines auto verification, validation, and control of code and container image integrity for seamless deployments in the K8s environment. The features together promote a robust development process and strict compliance.
+
+
+
+You made it! If you like what we are doing, check out [Compage on GitHub](https://github.com/intelops/compage). A star is always appreciated. We have more updates coming so, follow us on [LinkedIn](https://www.linkedin.com/company/intelopsai).

content/english/learning-center/Learn-DevOps/_index.md → content/english/learning-center/5-Learn-DevOps/_index.md

@@ -5,5 +5,5 @@ draft: false
 # description
 description: "Learning and implementation of devops process and experience the realtime scenarios"
 type : "learning-center"
-weight: 6
+weight: 5
 ---

content/english/learning-center/5-Learn-DevOps/monitoring-and-observability/_index.md

@@ -0,0 +1,8 @@
+---
+title: "Monitoring and Observability"
+date: 2023-04-22
+draft: false
+# description
+description: "Instrumentation"
+weight: 4
+---