DEV Community: Bella Souzas

Git Simplified: A Beginner's Guide to Version Control

Bella Souzas — Mon, 22 May 2023 20:21:57 +0000

If you're new to the world of software development, you might have heard the term "Git" thrown around quite a bit. Git is a powerful tool that developers use for version control, allowing them to track changes, collaborate with others, and manage their codebase efficiently. In this beginner-friendly blog post, we will demystify Git and explain its key concepts and benefits in simple terms.

What is Git?
Git is a distributed version control system (VCS) that helps developers manage and track changes to their codebase. It allows multiple developers to work on the same project simultaneously while keeping a detailed history of every change made. Git enables teams to collaborate seamlessly, revert changes when necessary, and maintain a clean and organized codebase.

Key Concepts of Git:

Repository: A Git repository, or repo for short, is like a central hub that stores all the project files and their history. It serves as a complete record of every change made to the codebase.

Commit: A commit represents a snapshot of the codebase at a specific point in time. It includes changes made to files and a message describing the purpose of the commit. Commits allow developers to track the evolution of the project and understand the context behind each change.

Branch: In Git, a branch is an independent line of development that allows developers to work on different features or bug fixes simultaneously. Each branch can have its commits and history. Branches provide isolation and flexibility, making it easier to experiment and collaborate without affecting the main codebase.

Merge: Merging is the process of combining changes from one branch into another. When a feature or bug fix is complete, it can be merged back into the main branch, often called the "master" or "main" branch. Merging ensures that all changes are integrated smoothly.

Why it's so important?

Version Control: Git keeps track of every change made to your codebase, allowing you to view and revert to any previous version easily. This provides a safety net and helps mitigate the risk of losing valuable code.

Collaboration: Git facilitates seamless collaboration among developers. Multiple team members can work on the same project simultaneously, making changes independently in their branches. Git enables smooth integration of these changes through merging, ensuring that everyone's work is accounted for.

Branching and Experimentation: With Git's branching feature, developers can create new branches to work on specific features or experiment with ideas without affecting the main codebase. This promotes a flexible and iterative development process.

Traceability and Accountability: Git provides a clear history of all changes made to the codebase. Each commit includes information about who made the change and why. This traceability enhances accountability and enables efficient debugging and issue resolution.

Git is an essential tool for modern software development, providing version control capabilities that empower developers to collaborate effectively and manage their codebase with ease. By understanding the key concepts of Git, such as repositories, commits, branches, and merging, you can take advantage of its benefits and streamline your development workflow. Whether you're working on a personal project or contributing to a large-scale team effort, Git's simplicity and power will undoubtedly enhance your coding journey.

Demystifying CI/CD: A Beginner's Guide to Continuous Integration and Continuous Delivery

Bella Souzas — Mon, 22 May 2023 20:17:02 +0000

In the world of software development, there are several key practices that enable teams to deliver high-quality applications efficiently. Two of the most important concepts are Continuous Integration (CI) and Continuous Delivery (CD). If you're new to these terms, don't worry! This blog post will explain CI/CD in simple terms, breaking down the concepts and benefits for beginners.

What is Continuous Integration (CI)?
Continuous Integration (CI) is a development practice that focuses on merging code changes from multiple developers into a shared repository frequently. The goal is to ensure that changes made by individual developers don't introduce conflicts or break the application. CI involves automating the process of building, testing, and validating code changes as soon as they are committed. By doing so, CI helps detect and resolve issues early, making it easier for teams to collaborate and maintain a stable codebase.

Benefits of CI:

Early Bug Detection: By integrating and testing code changes frequently, CI helps identify bugs and issues early in the development process. This allows developers to fix problems before they become more challenging and time-consuming to resolve.

Faster Feedback Loop: CI provides quick feedback to developers about the impact of their code changes. Automated tests run after every commit, providing valuable insights into the quality and functionality of the application. Developers can address issues promptly, ensuring a faster feedback loop and improved productivity.

Codebase Stability: With CI, teams can maintain a stable codebase by continuously integrating and validating code changes. This reduces the risk of integration problems and ensures that the application remains reliable, even as multiple developers work on different features simultaneously.

What is Continuous Delivery (CD)?
Continuous Delivery (CD) extends the principles of CI by automating the process of deploying applications to production environments. CD enables teams to release software reliably and frequently by automating various stages, including building, testing, and deploying the application. The goal is to have a deployment pipeline that allows for rapid and reliable releases, ensuring that the application is always in a deployable state.

Benefits of CD:

Faster Time to Market: CD enables teams to release new features, bug fixes, and improvements quickly and consistently. With automated deployment pipelines, the time required to deliver changes to end-users is significantly reduced, giving organizations a competitive edge in the market.

Reduced Risk: CD minimizes the risk of errors and inconsistencies that often arise during manual deployments. By automating the entire deployment process, CD ensures that every release goes through standardized tests and quality checks, reducing the likelihood of deployment-related issues.

Increased Customer Satisfaction: With CD, teams can respond to customer feedback and market demands swiftly. By continuously delivering incremental updates and improvements, organizations can provide a better user experience, address issues promptly, and deliver value to their customers consistently.

Continuous Integration (CI) and Continuous Delivery (CD) are crucial practices that empower software development teams to build, test, and deliver applications efficiently and with high quality. CI ensures that code changes from multiple developers are integrated and tested frequently, while CD automates the deployment process, allowing for reliable and rapid releases. By adopting CI/CD practices, organizations can enhance collaboration, reduce risks, and deliver software faster, ultimately improving customer satisfaction and gaining a competitive advantage in the ever-evolving world of software development.

O que é Audit Log?

Bella Souzas — Wed, 11 Nov 2020 22:01:12 +0000

A ideia do Audit Log é que sempre que acontecer algo importante, isso seja registrado, indicando o que aconteceu e quando aconteceu.

Existe alguns formatos que podem ser um audit log, como por exemplo;

um arquivo
- Caso use um arquivo precisará de um formato, um formulário ASCII ajuda a tornar mais legível a um ser humano sem software especial.
uma tabela de banco de dados
Estruturas mais complexas podem ser em formato XML

Os registros são fáceis de escrever, mas difíceis de ler, principalmente quando ficam grande.
Lembre-se sempre que a data de registro é sempre a data de processamento atual.

A limitação do registro de auditoria é a dificuldade de processar o registro.
É possível usar o audit log somente em algumas partes do modelo e outros padrões em outros. Sendo assim você pode usar o histórico em tempo real em algumas partes do projeto e outras com propriedade temporal, usando histórico de registro.

Resenha do texto de Martin Fowler

Benchmark para iniciantes - Go

Bella Souzas — Fri, 03 Jul 2020 19:27:01 +0000

Eu sempre ouvi sobre benchmark nos meetups, nas lives, nas discussões, mas eu achava que seria algo tão dificil que só poderia estudar quando eu estivesse bem mais avançada na linguagem. Sim, estudar testes tem sido um desafio grande, mas lendo alguns artigos, documentação da linguagem me surpreendeu sobre a implementação.

O benchmark é uma ferramenta incrível que o pacote testing oferece aos gophers. O benchmark é uma ferramenta de analise do desempenho do seu código em GO.

Para implementar uma função benchmark não tem mistério e pode orientar a você sobre como seu código vai performando ainda em execução.

ok, ok, chega de teoria e vamos para a prática…

Para implementar o benchmark vou usar como base a função Repeat que está salva no arquivo repeat.go.

package interation

const repeatCount = 5

// Repeat returns character repeated 5 times.
func Repeat(character string) string {
  var repeated string
  for i := 0; i < repeatCount; i++ {
     repeated += character
  }
  return repeated
}

No arquivo repeat_test.go eu implemento o teste da função e o benchmark usando o pacote “testing”.

package interation

import (
  "testing"

)

func TestRepeat(t *testing.T) {
  repeated := Repeat("a")
  expected := "aaaaa"

  if repeated != expected {
     t.Errorf("expected %q but got %q", expected, repeated)
  }
}

func BenchmarkRepeat(b *testing.B) {
  for i := 0; i < b.N; i++ {
     Repeat("a")
  }
}

Para “rodar” o test benchmark basta chamar em seu terminal go test -bench= ou ‘go test -bench="." ’ , caso voce esteja usando o windowns powershell.

No meu computador o resultado foi :

goarch: amd64
pkg: github.com/bellasouza/GOWithTest/interations
BenchmarkRepeat
BenchmarkRepeat-4        4988276           211 ns/op
PASS

Process finished with exit code 0

Esse resultado significa que a minha função leva em média 211 nanosegundos para rodar 4988276 vezes a função.

Considerações:

Esses são os materiais valiosíssimos que me ajudaram a entender melhor sobre benchmark.

Super indico a leitura: