DEV Community: Agatha Mendonça

Continuous Integration vs. Continuous Deployment: Understanding the Differences

Agatha Mendonça — Tue, 12 Dec 2023 15:37:09 +0000

Continuous Integration (CI) and Continuous Deployment (CD) are critical practices in modern software development. While they are often mentioned in the same breath and share common goals, their methodologies, purposes, and impacts on the development cycle are distinct. Understanding these differences is crucial for any development team seeking to optimize their workflow per their specific project needs.

What is Continuous Integration?

Continuous Integration is a development practice where developers merge their code changes into a central repository, typically multiple times daily. Each integration is verified by an automated build and testing process to catch integration mistakes as quickly as possible. The primary purpose of CI is to provide quick feedback so that if a defect is introduced into the codebase, it can be identified and fixed as soon as possible.

Benefits of Continuous Integration

Early Bug Detection: Frequent code integration helps identify incompatible code and bugs early in development.

Improved Code Quality: Regular testing ensures the codebase is robust and reliable.

Enhanced Collaboration: CI encourages more frequent code commits and better collaboration among team members.

Reduced Integration Problems: Regular integration reduces the chances of facing complex code merge conflicts at later stages.

What is Continuous Deployment?

Continuous Deployment takes the concept of CI further. Every change that passes the automated tests in CD is automatically deployed to production. This means there's no human intervention; only a failed test will stop a new change from being deployed to production.

Benefits of Continuous Deployment

Rapid Market Release: CD allows for faster delivery of features and updates to customers.

Consistent Deployment Process: Automation reduces the chances of human error during deployment.

Increased Productivity: Developers can focus more on development rather than deployment tasks.

Real-time Feedback: Immediate deployment means real-time feedback from end-users, which can lead to quicker improvements and enhancements.

Critical Differences Between CI and CD

Focus: CI is centered around integrating and frequently testing code changes, whereas CD focuses on automatically releasing those changes to production.

Automation Level: CI involves automated testing, but manual steps might still be present for deployment. CD extends automation to the deployment process itself.

Feedback Loop: CI provides feedback on code integrity and compatibility, while CD offers feedback on how changes perform in the production environment.

Deployment Frequency: CI does not necessarily mean frequent deployment, while CD ensures consistent and immediate deployment post-testing.

Choosing Between CI and CD

The choice between CI and CD should be influenced by the team's capacity, the nature of the project, and the business requirements. Teams prioritizing rapid market delivery and having robust testing processes in place may lean towards CD. On the other hand, teams focusing on stability and gradual changes might prefer CI.

The choice between CI and CD is not exclusive, as both practices can effectively complement each other. Let's expand on this by considering the integration of both CI and CD in a development process:

Using CI and CD Together:

Complementary Practices: CI and CD can be viewed as complementary rather than mutually exclusive. CI focuses on integrating and testing code changes, ensuring code quality and stability. CD builds upon the solid foundation provided by CI to automate the deployment process, making the release of new features and updates more efficient.

Continuous Workflow: By integrating CI and CD, teams can establish a constant workflow where code is integrated and tested frequently and deployed seamlessly to production upon passing all tests. This integration ensures a streamlined path from code development to deployment.

Adaptability to Project Needs: The combination of CI and CD offers flexibility to adapt to various project needs. For instance, while CI maintains the code's stability and quality, the CD brings agility in responding to market demands or user feedback quickly.

Balancing Speed and Stability: Using CI and CD together allows teams to balance the need for rapid market delivery with maintaining a stable and reliable codebase. This balance is crucial in environments where both aspects are equally important.

Robust Testing Framework: A powerful automated testing framework is critical to successfully integrating CI and CD. Such a framework ensures that the rapid deployment enabled by CD does not compromise the quality and reliability provided by CI.

Resource Allocation: Implementing both CI and CD may require thoughtful allocation of resources, as both practices demand tooling, infrastructure, and expertise. However, the investment can significantly improve development efficiency and product quality.

Cultural Shift: Embracing both CI and CD requires a cultural shift within the team, emphasizing collaboration, continuous improvement, and a willingness to adapt processes for better efficiency and quality.

Continuous Feedback Loop: By integrating CI and CD, teams benefit from a constant feedback loop, where code is tested for integrity and its performance and usability in the real-world environment.

Conclusion

While closely related, continuous integration and deployment supply different parts of the software development lifecycle. CI is about integrating and testing changes quickly and frequently, ensuring code quality and compatibility. CD extends this to automatically deploy every validated change, reducing time-to-market and enabling immediate user feedback. Understanding their differences allows teams to effectively leverage these practices to suit their unique development needs and goals.

Micro Frontends: Integrating UIs in Microservices Architecture

Agatha Mendonça — Wed, 06 Dec 2023 18:55:02 +0000

In the ever-evolving landscape of software development, the concept of microservices has gained considerable traction for its ability to enhance scalability, maintainability, and overall agility. As organizations embrace the microservices architecture to break down monolithic applications, attention turns to the front end – a crucial forgotten aspect. This article explores the paradigm of Micro Frontends, shedding light on how they coherently integrate with microservices architecture, offering a holistic approach to building modern and scalable web applications.

Understanding Micro Frontends

Micro Frontends extend microservices principles to an application's frontend layer. Instead of having a monolithic frontend codebase, developers can create smaller, self-contained modules responsible for a specific functionality or feature. This approach allows teams to work independently on different parts of the user interface, enabling a more agile and collaborative development process. Each Micro Frontend works as a standalone unit, letting the teams choose the technology stack, frameworks, or libraries that best suit the requirements of their specific module.

Benefits of Micro Frontends

1. Independent Development and Deployment: One of the critical advantages of Micro Frontends is the autonomy it provides to development teams. Teams can work on their respective modules without being tightly coupled to the development lifecycle of other teams. This autonomy extends to deployment, allowing for independent releases and updates, reducing the risk of system-wide failures, and enabling faster time-to-market for new features.

2. Technology Diversity: In a microservices ecosystem, different services might be built using various technologies to address specific use cases efficiently. Micro Frontends embrace a similar philosophy, allowing teams to choose the most suitable tools and frameworks for their module. This flexibility ensures that each team can leverage the best technology to meet the unique requirements of their part of the user interface.

3. Improved Scalability: Micro frontends enhance scalability by enabling teams to independently scale specific parts of the user interface. In a monolithic front, scaling often involves replicating the entire application, even if only a particular feature requires additional resources. With Micro Frontends, teams can scale the components that experience increased demand without affecting the whole application.

Challenges and Solutions

While Micro Frontends offer numerous benefits, they also come with challenges that need to be addressed:

1. Consistent User Experience: Coordinating different Micro Frontends to provide a cohesive user experience can be challenging. Solutions involve establishing shared design systems, defining communication protocols, and implementing consistent navigation patterns.

2. Cross-Cutting Concerns: Managing cross-cutting concerns like authentication, authorization, and data fetching requires careful consideration. Implementing a shared infrastructure or utilizing API gateways can address these challenges.

3. Versioning and Dependency Management: Ensuring that different Micro Frontends work together, specifically when using different versions of libraries or frameworks, necessitates robust versioning and dependency management strategies.

Conclusion

In the era of microservices, Micro Frontends emerge as a natural progression to create truly decoupled and independently scalable web applications. This approach empowers development teams, enhances agility, and fosters a modular architecture that aligns with the principles of microservices. As organizations navigate the complex terrain of modern software development, integrating Micro Frontends becomes a strategic choice to build resilient, scalable, and user-friendly applications.

Microservices Unleashed: A Comprehensive Guide

Agatha Mendonça — Mon, 04 Dec 2023 13:24:20 +0000

Software architecture is constantly changing, and microservices have emerged as a transformative paradigm that is revolutionizing how we design and deploy applications. This comprehensive guide is designed to help you understand the ins and outs of microservices and provide insights into their principles, benefits, challenges, and best practices. Get ready for a journey through microservices, where agility, scalability, and resilience come together.

The Microservices Revolution

In the trace of technical evolution, the Microservices Revolution has emerged as a transformative force, showing the course of software architecture away from traditional monolithic structures. This paradigm change advocates decomposing applications into small, independently deployable services, each catering to a specific functionality. This article fully explores the driving forces behind the microservices revolution, separating the core principles that have driven its adoption across the software development landscape. Examining its benefits, from improved scalability to enhanced resilience, illuminates the profound impact of microservices on how we conceptualize and build applications.

Principles of Microservices Design

At the core of effective microservices architecture lie guiding principles that shape the design and implementation of these decentralized and modular systems. One fundamental concept is service autonomy, which empowers each microservice to operate independently, making decisions and managing its resources autonomously. Dig into decentralized data management, this paradigm ensures that each microservice handles its data, minimizing dependencies and enabling a more scalable and resilient architecture. Additionally, the principle of continuous delivery highlights the importance of a streamlined and automatic deployment process, enabling rapid and efficient updates. By exploring these foundational principles, one understands how they collectively contribute to the agility, scalability, and adaptability of microservices in the dynamic landscape of modern software development.

As we navigate the complexities of microservices design, these principles act as the building blocks that define the architecture structure and influence how individual services interact and evolve over time. This exploration sheds light on the complex web of decisions that architects and developers make to create systems that meet the technical requirements of scalability and resilience and align with the overarching philosophy of microservices. This approach thrives on flexibility and responsiveness in the ever-changing domain of software development.

Breaking Down Monoliths: Migration Strategies

Launching from monolithic architectures to microservices requires careful consideration and strategic planning. In this exploration of migration strategies, organizations can discover practical approaches to breaking down monoliths without compromising system integrity. The strangler pattern, a widely adopted strategy, involves gradually replacing monolith components with microservices, allowing the new architecture to "strangle" the old one over time. Blue-green deployments offer another avenue, enabling a smooth transition by running both the monolithic and microservices versions together, with the ability to switch between them seamlessly. By delving into these proven strategies and understanding their nuances, organizations can confidently navigate the complex process of migrating to microservices, minimizing disorders, and ensuring a successful software architecture evolution.

These migration strategies are valuable tools for organizations seeking to modernize their software systems. Carefully orchestrating these techniques facilitates a seamless transition and empowers teams to iteratively improve their architecture, adapting to changing business needs and technological advancements. As organizations embrace the era of microservices, these migration strategies become essential components of a successful transformation, guiding them toward a more modular, scalable, and resilient software landscape.

Challenges in Microservices Adoption

Adopting microservices introduces organizations to new challenges that necessitate thoughtful solutions. One critical aspect is service orchestration, where the coordination of multiple services becomes crucial for seamless functionality. Additionally, the complex landscape of data consistency in a microservices environment is addressed, offering insights into strategies for maintaining coherence across distributed data stores. Understanding the intricacies of communication between services is also paramount, and organizations can explore best practices and technologies that foster efficient and reliable interactions among microservices.

Navigating the challenges of microservices adoption requires a holistic approach encompassing various facets of system design and operation. Organizations can fortify their microservices architecture by addressing issues related to service orchestration, data consistency, and communication. This strategic consideration ensures that the touted benefits of microservices, such as scalability, resilience, and agility, are maximized while effectively mitigating the challenges inherent in this transformative architectural paradigm.

Tools and Technologies in the Microservices Ecosystem

The microservices landscape is enhanced by diverse tools and technologies catering to various development and deployment aspects. Dive into the world of containerization with Docker, a powerful tool that encapsulates microservices and their dependencies, providing consistency across different environments. Additionally, the orchestration prowess of Kubernetes takes center stage, offering a robust framework for automating the deployment, scaling, and management of containerized applications. These technologies, among others, form the foundational building blocks that empower organizations to unlock the full potential of microservices, fostering scalability, flexibility, and efficient management of complex distributed systems.

In this exploration of the microservices ecosystem, organizations can tailor their toolkit to align with specific needs and preferences. Whether leveraging containerization for encapsulation or harnessing orchestration solutions for streamlined deployment, the array of tools available contributes to creating a resilient and agile microservices architecture. This section provides a glimpse into the dynamic and ever-evolving toolbox that organizations can use to successfully navigate the intricacies of microservices development and deployment.

Microservices Best Practices

Embarking on the journey of microservices development requires a solid foundation of best practices to ensure the creation of robust and maintainable solutions. This section delves into the intricacies of API design, shedding light on practices that facilitate seamless communication between microservices. From defining clear and concise interfaces to incorporating RESTful principles, a thoughtful approach to API design contributes to microservices' overall agility and interoperability.

Above API design, this exploration extends to critical aspects such as logging, monitoring, and testing. Discover the significance of comprehensive logging to facilitate troubleshooting and gain insights into the system's behavior. Uncover the importance of robust monitoring strategies, enabling real-time visibility into the performance and health of microservices. Additionally, delve into effective testing methodologies, ensuring the reliability and resilience of microservices under diverse scenarios. By embracing these best practices, developers and architects can confidently navigate the complexities of microservices development, fostering a culture of innovation and stability within their software ecosystems.

Real-world Microservices Implementations

In exploring microservices implementations, real-world examples take center stage, providing tangible insights into the transformative impact of adopting this architectural paradigm. Case studies from industry leaders serve as compelling narratives, illustrating how microservices have become instrumental in achieving scalability, fostering agility, and responding adeptly to evolving business demands. By delving into these success stories, readers gain valuable perspectives on the practical application of microservices, discovering how organizations across diverse sectors have harnessed their potential to navigate the complexities of modern software development.

These case studies illuminate the benefits and offer a nuanced understanding of the challenges encountered when adopting microservices. From overcoming initial hurdles to realizing long-term strategic advantages, these real-world examples provide a holistic view of organizations' journey when embracing microservices. This exploration serves as a source of inspiration for those considering or currently navigating the microservices landscape, offering valuable lessons learned and best practices distilled from the experiences of pioneers.

Security Considerations in Microservices

In microservices, prioritizing security is a non-negotiable aspect, given the distributed nature of this architectural paradigm. This section delves into the distinctive security challenges in microservices environments and offers a comprehensive exploration of strategies to mitigate these challenges effectively. From ensuring secure service-to-service communication to implementing robust authentication mechanisms, readers will gain insights into safeguarding their microservices ecosystems against common vulnerabilities and potential threats.

Understanding the intricacies of security in microservices goes beyond traditional monolithic approaches, requiring a nuanced understanding of the unique aspects of decentralized architectures. By navigating through the security considerations specific to microservices, this section empowers developers and architects to implement robust measures that protect against potential risks and fortify the overall security posture of their microservices-based applications.

The Future of Microservices: Trends and Innovations

As technology relentlessly advances, the trajectory of microservices evolves in tandem, ushering in new paradigms and innovations. This section serves as a window into the future of microservices, unraveling emerging trends poised to shape the landscape. From the rise of serverless microservices that abstract infrastructure concerns to the prominence of event-driven architectures reshaping how systems respond to stimuli, readers will gain insights into the cutting-edge developments propelling the microservices ecosystem forward.

The future of microservices is marked by technological advancements and the symbiotic relationship with artificial intelligence (AI). This section explores how AI is becoming integral to microservices ecosystems, enhancing adaptability and intelligent decision-making within distributed architectures. By delving into these trends and innovations, readers will be well-equipped to anticipate the trajectory of microservices and strategically leverage these advancements in their future architectural endeavors.

Embracing Microservices: A Call to Action

In conclusion, this comprehensive guide culminates with a compelling call to action for organizations poised at the threshold of a microservices transformation. The section underscores the transformative potential inherent in microservices when approached with strategic planning and meticulous execution. It advocates for organizations to embrace this architectural paradigm, envisioning a future marked by increased agility, scalability, and resilience – essential attributes in the dynamic landscape of modern software development.

This call to action is an invitation and a strategic imperative for organizations looking to thrive in the ever-evolving digital ecosystem. By adopting microservices, organizations can respond adeptly to changing business demands, innovate swiftly, and build systems that are resilient and poised for sustained success in the digital era.

An Introduction to Domain-Driven Design

Agatha Mendonça — Sat, 02 Dec 2023 13:33:05 +0000

Domain-Driven Design (DDD) is a robust methodology reshaping the software development landscape. It offers an organized approach to crafting complex systems that harmonize with the complexities of their respective business domains. In this brief exploration, we will unravel the fundamental principles and concepts that constitute the foundation of DDD.

Understanding the Essence of DDD

At its core, DDD acts as a motivation for cultivating a shared understanding between technical and domain experts. The main goal is to create software that mirrors the complexities intrinsic to the real-world business it seeks to serve. Central to DDD is an emphasis on the domain – the specific problem space the software efforts to address. This focal point guides the creation of a universal language, a shared vocabulary meticulously crafted to facilitate seamless communication among all stakeholders involved in the software development process.

In the realm of DDD, following this shared language goes beyond formality; it becomes a cornerstone for effective collaboration. By establishing a linguistic common ground, technical and domain experts can seamlessly better communication barriers, adjusting their insights and perspectives. This shared understanding becomes the linchpin for building software solutions that meet technical specifications and, more critically, reverberate with the complexities of the business domain they are designed to navigate.

Bounded Contexts

A foundational concept in DDD is the notion of Bounded Contexts. These explicit boundaries trace where a specific model or term holds a precise and contextual meaning. The intrinsic value of Bounded Contexts is illuminated by the understanding that the same term may carry disparate interpretations in various contexts. Consequently, these boundaries detailed knowledge and definition become necessary, safeguarding against potential ambiguity and miscommunication.

Bounded Contexts emerge as navigational beacons, showing the development process with clarity and coherence by navigating the expansive landscape of a business domain. By establishing these clear lines, DDD empowers teams to cultivate a shared understanding, providing that stakeholders across different contexts align their interpretations, enabling a unified and practical approach to software development within the diverse complexness of the problem space.

Aggregates and Entities

Within DDD, the bedrock of business logic rooms in the encapsulation provided by Aggregates and Entities. Aggregates serve as clusters of connected objects treated as a cohesive unit, offering a holistic approach to managing complex business processes. In parallel, Entities represent objects within the system described by a distinct identity, offering a granular understanding of individual components. Together, these building blocks form the cornerstone of DDD, empowering developers to architect solutions with a clear and organized structure.

The essence of Aggregates and Entities lies in their structural significance and capacity to illuminate the complex relationships within the business domain. DDD enables a nuanced representation of real-world complexities by encapsulating related objects and delineating distinct identities, enabling a modular and comprehensible architecture. This approach enhances the system's manageability and facilitates a more profound understanding of the dynamic interplay between various components, contributing to the efficacy of the software development process.

Value Objects

In the DDD framework, Value Objects emerge as critical components, assimilating descriptive facets of the domain without having a distinct identity. Unlike Entities, Value Objects are characterized by immutability, which focuses on capturing inherent characteristics rather than mutable states. This emphasis on immutability contributes to improved predictability, offering a stable foundation for modeling aspects of the business domain that remain consistent.

The significance of Value Objects extends beyond their immutability, delving into their role in fostering reusability across diverse system segments. DDD allows these objects to be effortlessly employed across various application parts by encapsulating descriptive attributes in an immutable form, promoting a modular and efficient approach to software development. This dual focus on immutability and reusability ensures that Value Objects become versatile building blocks, capable of seamlessly integrating into different contexts within the dynamic landscape of the business domain.

Strategic Design

At the core of DDD lies the tenet of Strategic Design, a holistic approach that intricately incorporates the fabric of software architecture with the business's strategic goals. This multifaceted process involves identifying and sketching Subdomains – discrete segments within the business domain, each with unique features and challenges. The essence of Strategic Design lies in establishing a lucid and purposeful relationship between these Subdomains, ensuring that the software architecture evolves in a team with the overarching strategic objectives of the business.

The symbiotic relationship between software architecture and business goals, enabled by Strategic Design, creates a dynamic and responsive environment. This alignment ensures that the software stays not only a reflection of the current state of the business but also a proactive instrument capable of adapting to the evolving landscape. By strategically mapping the complex Subdomains and their interconnections, DDD authorizes organizations to build software solutions that seamlessly resonate with the strategic heartbeat of the business, promoting a balanced and effective evolution over time.

Event Storming

The collaborative workshop technique, called Event Storming, is embedded within the DDD fabric. This dynamic practice catalyzes teamwork and collective exploration among team members, especially in modeling complex business domains. Event Storming extends as a visual journey, weaving together events, commands, and aggregates in a concrete representation that exceeds the complexities of the business domain. This collaborative visualization becomes a powerful tool for cultivating shared understanding among team members.

The essence of Event Storming lies not just in its visual prowess but in its ability to lay the foundational groundwork for effective modeling. Event Storming catalyzes creativity by providing a canvas for team members to collectively explore and express various aspects of the business domain. This ensures that diverse perspectives contribute to a complete and refined model. This collaborative approach facilitates communication and sets the stage for a robust and well-informed foundation upon which subsequent stages of the software development process can unfold.

In conclusion, Domain-Driven Design is more than a set of principles; it's a mindset shift that places the business domain at the forefront of software development. DDD empowers teams to create software systems that meet technical requirements and reflect the complexities of the real-world problems they aim to solve by promoting collaboration, adopting clear boundaries, and strategically aligning with business goals.

What is cloud computing?

Agatha Mendonça — Fri, 04 Mar 2022 15:19:50 +0000

Once upon a time, when the internet was created, companies how what have their websites online should have a physical infrastructure that takes space. They are also expensive, giving the companies a hard time when they want to scale their serves.

While more companies want to join the world wide web, the need for servers hoe take less space and don't cost so much to be implemented surge, and companies were AWS, Azure, and Google cloud start offer servers that other companies can use on they need this is called cloud computing.

They have servers with remote access that companies can pay only when they use, removing the need for companies to keep a structure on their builds. For this reason, companies of all sizes now can have their systems online even if they don't have an actual office.

Cloud computing turned the internet into a more accessible place for small companies making it shipper and fast to create a server infrastructure while giving all companies more possibilities. It is possible to create identical environments for test and production and provide accessible support for growth and expansion.

Types of cloud computing

There are three main types of cloud computing when we talk about the service model: Infrastructure as a service, Platform as a service, and Software as a service.

Infrastructure as a service (IaaS): Typically contains essential for cloud, has dedicated or virtual hardware, data storage, and virtual systems. Giving the user more control and flexibility.

Platform as a service (PaaS): Give access to hardware and operations systems that allow the client to focus on the application since it takes care of the server's capacity software license, providing all the support for a web application.

Software as a service(SaaS): Provides a complete application managed for the service provider. They are end-user applications, excluding the worry about running or handling them.

Leia em Portugues

React: How should I start?

Agatha Mendonça — Sun, 05 Dec 2021 20:13:56 +0000

I was skeptical about React when I first started learning to code. As I learned about organizing CSS and HTML from within JavaScript, the idea of React's approach - to put them together - seemed counterintuitive. So, I tried using alternative libraries for a while to avoid React.

But when I finally gave React a chance, I realized how powerful it can be. As I've worked with it over the past few years, I've learned much about how to get the most out of this famous library.

In this article, I'd like to share some of the insights I've gained from my experience working with React.

But what is this thing called React?

Even if you're new to web development, you've likely heard of React. Maybe you've seen a tutorial or read an article about one of the most popular JavaScript libraries, but you might still wonder: "What exactly is React?"

Simply put, React is an open-source library created by Facebook. It's designed to function as the View layer in an MVC (Model-View-Controller) application. What sets React apart is its ability to create reusable, custom HTML elements, which makes developing user interfaces much more efficient. This is why React has become such a popular choice for web developers.

Should I start learning React?

Quickly answer is yes. React is a powerful library with many opportunities; more companies use React daily in their applications.

But if you start with coding, you need some structure before jumping into React, or your experience will be disappointing and frustrating. I recommend you first build a good understanding of HTML and CSS, learning javascript will also be essential, and last, you should comprehend the basics of DOM.

How do I start with React?

If you're starting with React, the easiest way to begin using it is by including static links in your HTML file. While this approach differs from how you would use React in a real-world application, it's a great way to explore the library and start learning.

To use React with static links, you only need to copy and paste the scripts into your HTML file. That's it! From there, you can start coding and experimenting with React's capabilities.

<script src="https://unpkg.com/react@17/umd/react.development.js" crossorigin></script>
<script src="https://unpkg.com/react-dom@17/umd/react-dom.development.js" crossorigin></script>

but let's do it the right way

Creating a React Application

To begin, we must ensure that our machine has node ≥ 14 and npm ≥ 5.6 pre-installed, which are required to use create-react-app.

npx create-react-app app-name
cd app-name
npm start

Once these dependencies are installed, we can run the first command to create a folder with the name of our application. This folder will contain a basic structure and the necessary packages to start building our application. Afterward, we can use 'npm start' to launch our application and open a page, as shown in the image below.

For this tutorial, we will focus on our project's "src" folder, where we will find some files.

The following files are included:

"App.css": styles related to the "App" component
"App.js": contains a React component named "App"
"index.css": default styles for the application
"index.js": renders our component
"logo.svg": React logo used in "App.js"
"reportWebVitals.js": contains a function that allows measuring the application's performance
"setupTests.js": configures the application's tests

For now, we will only modify the "App.js" file by replacing all the content inside the "return" with a simple "h1".

function App() {
  return (
    <h1>Hello Word!</h1>
  );
}

export default App;

So when we go back to our page in the browser, we will have:

In summary, any tags placed in the return statement of the App component will be displayed on the screen. However, it is important to note that the tags used in React are not HTML, but rather React components. While they may look similar, some attributes can be different, such as the commonly used CSS class attribute which is replaced with className in React.

With this understanding, you can explore React components and make the desired changes in your project.

Read this in Portuguese