Introduction

Hey, guys! I hope everyone is doing well!

Today, I’ll be starting a new series of articles dedicated to a topic that interests me a lot: Software Performance. It’s a subject that I find few materials about on the internet, but it’s extremely important, especially in the context of large-scale software.

In this initial article, my goal is to present a more theoretical approach, providing an overview of performance. However, in the upcoming editions, I intend to bring a more practical bias.

Without further ado, let’s get started! :)

1.1 Contextualization

Software Performance Testing plays a crucial role in today’s scenario, characterized by speed and intense competition among companies. In this context, organizations face the constant demand to deliver high-quality products and services while simultaneously meeting customer expectations.

1.2 Real World Scenario

“ […] The retailer’s website crashed at the same time its Prime Day deals were scheduled to begin in the United States, on Monday, July 16, at 3 p.m. ET. The site responded with a 404 error. […] ”

“ […] Some customers are having difficulty shopping, and we’re working to resolve this issue quickly,” Amazon said […] ”

1.3 Benefits of Performance Testing

By evaluating the speed, scalability, and stability of applications, websites, and other digital products, performance testing plays a fundamental role in identifying and resolving any issues before they impact end-users.

Analysis of the data resulting from tests reveals improvement opportunities, allowing the implementation of corrective actions and adjustments during development. This prevents downtime, failures, and other performance-related issues.

This approach not only increases customer satisfaction but also provides essential answers to key questions such as:

“Is my application operating efficiently?”

“What is its performance in different scenarios, such as X or Y?”

2.0 Performance Testing Scenarios

When we think about scenarios for Performance Testing, there are two models:

Both scenarios are essential to ensure the efficiency and proper functioning of the software. “End to End” testing evaluates the overall performance of the system, while isolated testing allows optimization of specific components.

3.0 Types of Performance Testing

There are various approaches to performance testing, but generally, they focus on the following types:

3.1 Load Testing

Load testing plays a crucial role in capacity planning, ensuring that a system can handle the growth of simultaneous user traffic.

Its role lies in the system’s ability to manage an increase in actual load levels, derived from user requests or controlled processes. This approach seeks to anticipate challenges, ensuring the system’s efficiency in the face of growing demands.

3.2 Stress Testing

Stress testing focuses on a system’s or component’s ability to handle user load spikes that exceed predicted or specified limits. Additionally, it evaluates the system’s ability to cope with reduced infrastructure resources, such as processing capacity, bandwidth, and memory.

3.3 Spike Testing

Spike testing aims to test the maximum capacity of an application to handle a very high workload in a short period of time.

This test helps determine if the system’s performance deteriorates when there is a sudden increase in load. Another goal of this test is to determine the system’s recovery time. Between two consecutive user load peaks, the system needs some time to stabilize. This recovery time should be as low as possible.

3.4 Endurance Testing

Endurance testing verifies a system’s ability to continue operating stably under a constant workload, usually for an extended period.

The goal is to assess the system’s ability to handle a constant load without experiencing resource problems such as memory leaks, database connection overload, or other types of failures that could negatively affect system performance and cause disruptions.

4.0 How to Evaluate Performance Testing?

During a performance test, it is essential to analyze various metrics to evaluate the system’s performance. Some of the main ones include:

4.1 Response Times

The total time elapsed from the user’s request to the delivery of a response to a request is a common measure of application performance. This measure is usually expressed in milliseconds, according to market standards.

4.2 Throughput

Throughput measures the number of requests a system can process within a certain period of time. This metric is usually measured in requests per second (RPS).

It is important that the throughput graph can keep up with the growth of user load to ensure that the system can handle increased traffic.

If throughput does not increase proportionally to user load, it may indicate performance bottlenecks that need to be investigated.

4.3 Percentile

The percentile is a measure that divides a sample of ordered values into one hundred parts, used to analyze the distribution of response times in ascending order. Different percentiles, such as the 50th, 90th, and 95th, can be established to identify specific points of interest.

This approach ensures that all previous points are below this value, while subsequent points are above it, providing a detailed understanding of the data distribution.

4.4 Error Rate

The error rate is the indicator that calculates the percentage of requests with errors relative to the total number of requests.

When we talk about Web applications, whenever a request is made to the application, the server will return an HTTP code. This code indicates whether the request was successful, if there was any redirection, or if something went wrong. These codes are classified into the following ranges:

Returns with error codes 4xx and 5xx increase the error rate and can help identify when the application began to not support the volume of accesses.

It is important to note that these codes do not inform about the cause of the problem but guide the error investigation.

5.0 Sources and References

My main reference in creating this article is the Performance Testing certification from the ISTQB (International Software Testing Qualifications Board) institution.

For more detailed information, I recommend taking a look at the official documentation through the following link:

Welcome to ISTQB®

Additionally, a great site to learn about performance is Blazemeter:

BlazeMeter Continuous Testing | BlazeMeter by Perforce

Follow me on social media:

LinkedIn — (https://www.linkedin.com/in/jvroot/)

Github — (https://github.com/JV-root)

Corki’s thumbs up:

1.0 Introdução

Fala, pessoal! Sejam muito bem-vindos à mais uma etapa da nossa jornada de aprendizado de Matemática com Python!

Nesta edição, escrevi bastante sobre a parte histórica do tema, pois confesso que me divirto muito aprendendo sobre. Então para aqueles que desejam ir diretamente à aplicação em Python, pulem para a parte 3.0 Noções de Lógica Booliana em Python.

Sem mais enrolação, vamos nessa!

2.0 Noções de Lógica

A lógica é o alicerce da matemática, proporcionando as regras essenciais do raciocínio e fundamentando as decisões sobre a validade de argumentos e proposições.

Além do campo da matemática, na Ciência da Computação, a lógica tem um papel crucial. Um raciocínio lógico sólido é essencial para a construção de códigos com desempenho otimizado, melhor legibilidade e dinamicidade.

“Ela [a Lógica] lhe dará clareza de pensamento, a habilidade de ver seu caminho através de um quebra-cabeça, o hábito de arranjar suas ideias numa forma acessível e ordenada e, mais valioso que tudo, o poder de detectar falácias e despedaçar os argumentos ilógicos e inconsistentes que você encontrará tão facilmente nos livros, jornais, na linguagem cotidiana e mesmo nos sermões e que tão facilmente enganam aqueles que nunca tiveram o trabalho de instruir-se nesta fascinante arte” — Lewis Carrol

Mas como tudo isso teve início?

2.1 A Lógica Aristotélica

Na Grécia Clássica, por volta de 350 a,C., o pensador grego Aristóteles desenvolveu a primeira tentativa para estabelecer os princípios fundamentais da lógica.

Insatisfeito com o método dialético de Sócrates, que se baseava em questionar hipóteses expondo incoerências e contradições, Aristóteles buscou estruturar argumentos lógicos de maneira sistemática. Ele identificou diferentes tipos de proposições e introduziu o conceito de silogismo, uma forma lógica composta por duas premissas que levam a uma conclusão.

O mais famoso exemplo de silogismo é:

“Todos os homens são mortais.

Aristóteles é homem,

Logo,

Aristóteles é mortal.”

2.2 A Álgebra Booliana

No século XIX, um momento crucial marcou o início da lógica como uma disciplina da matemática. George Boole, um renomado matemático britânico, envolveu-se em uma disputa filosófica com o seu amigo Augustus De Morgan (guarde esse nome) sobre a autoria de uma ideia específica.

Embora Boole não estivesse diretamente envolvido, o evento o inspirou a desenvolver suas ideias sobre a formalização da lógica por meio da matemática, como descrito em seu ensaio de 1847, intitulado “Análise Matemática da Lógica”.

Boole queria formular argumentos lógicos de maneira que pudessem ser manipulados e resolvidos matematicamente. Para alcançar esse objetivo, ele introduziu uma espécie de álgebra linguística, substituindo as operações comuns da álgebra, como adição e multiplicação, pelos conectores utilizados na lógica.

Similar à álgebra, o uso de símbolos e conectivos por Boole permitiu a simplificação de expressões lógicas.

As três principais operações da álgebra booleana são:

E (AND), OU (OR) e NÃO (NOT)

Boole acreditava que essas eram as únicas operações necessárias para realizar comparações de conjuntos, assim como funções matemáticas básicas.

E onde mais você encontra operações que resultam em 1 (True) ou 0 (False)? ISSO MESMO, NO PYTHON!

3.0 Noções de Lógica Booliana em Python

Antes de mais nada, gostaria de falar um pouco sobre a biblioteca que iremos utilizar nesta aula e em 99% das aulas aqui pra frente.

3.1 Sympy

O Sympy é uma biblioteca de computação simbólica em Python, amplamente reconhecida por sua eficiência e versatilidade no processamento de expressões matemáticas complexas.

Com o Sympy, podemos realizar uma variedade de operações matemáticas, desde simplificações algébricas até cálculos de integrais e diferenciação simbólica (Alô pessoal de Calculo, essa é para vocês! 🧙‍♂️).

Um Exemplo maneiro do Sympy com equação:

agora um exemplo mais complexo:

Inicialmente, pode parecer bastante coisa para absorver, porém, o Sympy é uma biblioteca muito maneira para aprender. Quando combinado com o LaTeX, se torna um conjunto poderoso de ferramentas para entender os conceitos matemáticos.

Abordarei outros aspectos do Sympy em momentos subsequentes.

Finalmente, vamos aos conceitos:

3.2 Preposição

Um dos principais conceitos em lógica é o de preposições (ou proposições) que basicamente é uma afirmação que pode ser claramente identificada como verdadeira ou falsa.

Por exemplo, a afirmação:

𝑃: ‘O céu é azul’

É uma proposição porque pode ser verificada e classificada como verdadeira ou falsa.

Além disso, existem outras regras importantes ao se criar uma preposição:

• Simplicidade — Deve ser simples, contendo apenas uma afirmação básica.
• Clareza na Linguagem — A linguagem usada deve ser precisa, evitando ambiguidades.
• Consistência Interna — Não pode conter contradições internas.
• Completude — Deve ser completa o suficiente para determinar sua veracidade ou falsidade.
• Independência — Cada proposição deve ser independente de outras.

Demostrando em Python fica assim:

É importante salientar que nem todas as afirmações ou frases podem ser classificadas como proposições. Aqui estão alguns exemplos de coisas que não são proposições:

3.3 Negação

A negação de uma proposição é a operação lógica que inverte o seu valor de verdade. Se uma proposição ‘p’ é verdadeira, a sua negação, denotada por ‘~p’ ou ‘não p’, é falsa, e vice-versa.

Por exemplo, a afirmação:

p: ‘O céu é azul’

Sua negação é:

~p: ‘O céu não é azul’

a negação de uma preposição tem suas regras também, e são elas:

• Lei da Dupla Negação: A negação da negação de uma proposição P é equivalente a P. Ou seja, Matematicamente, ∼(∼𝑃)=𝑃
• Lei da Contradição:Uma proposição e sua negação não podem ser ambas verdadeiras ao mesmo tempo.Matematicamente, 𝑃 ∨ ¬ 𝑃 = False
• Lei do Terceiro Excluído: Para qualquer proposição 𝑃, a proposição 𝑃 ∨¬𝑃 é sempre verdadeira. Matematicamente, 𝑃 ∨¬ 𝑃= True

Demostrando em Python fica assim:

3.4 Proposições Composta

Uma proposição composta é formada pela combinação de duas ou mais proposições simples, utilizando conectivos lógicos como ‘e’ (conjunção), ‘ou’ (disjunção), ‘se… então…’ (condicional) e ‘se e somente se’ (bicondicional).

Antes de irmos para os conectivos lógicos, é importante abordar o conceito de Tabela Verdade.

3.4.1 Tabela Verdade

A tabela verdade é uma representação tabular que mostra todas as combinações possíveis de valores (Verdadeiro ou Falso) para uma dada proposição composta.

É um recurso muito útil para analisar argumentos e expressões lógicas.

3.4.2 Conjunção

A conjunção de proposições, muitas vezes representada pelo operador lógico “E” (∧), é uma operação que combina duas proposições para formar uma nova proposição composta.

Vamos chamar as duas proposições de 𝑃 e 𝑄.

• A conjunção 𝑃∧𝑄 é verdadeira somente quando ambas as proposições 𝑃 e 𝑄 são verdadeiras.
• Se qualquer uma das partes for falsa, a proposição composta também será falsa.

Tabela Verdade Conjunção

3.4.3 Disjunção

A disjunção de proposições, frequentemente representada pelo operador lógico “OU” (∨), é uma operação que combina duas proposições para formar uma nova proposição composta.

Vamos chamar as duas proposições de 𝑃 e 𝑄.

• A disjunção 𝑃∨𝑄 é verdadeira se pelo menos uma das proposições 𝑃 ou 𝑄 for verdadeira.

Tabela Verdade Disjunção

3.4.4 Condicionais

As condicionais de proposições, frequentemente representadas pelo operador lógico “Se… então…” (→), são uma forma de implicação lógica. Vamos chamar as duas proposições de 𝑃 (antecedente) e 𝑄 (consequente).

A condicional 𝑃→𝑄 é uma afirmação que estabelece uma relação entre as duas proposições da seguinte maneira: se 𝑃 for verdadeiro, então 𝑄 também é verdadeiro.

Lei do Modus Ponens:

• Se 𝑃→𝑄 é verdadeiro e 𝑃 é verdadeiro, então podemos concluir que 𝑄 também é verdadeiro.

Lei do Silogismo Hipotético:

• Se 𝑃→𝑄 e 𝑄→𝑅 são ambos verdadeiros, então podemos concluir que 𝑃→𝑅 é verdadeiro.

Contrapositiva:

• A contrapositiva de 𝑃→𝑄 é ¬𝑄→¬𝑃.Se a contrapositiva é verdadeira, então a condicional original também é verdadeira.

Vamos a um exemplo de Condicionais em Python:

Tabela Verdade Condicionais

3.4.5 Bicondicionais

Uma proposição bicondicional, frequentemente denotada por 𝑃↔𝑄 expressa uma relação “se e somente se” entre duas proposições 𝑃 e 𝑄. A proposição bicondicional é verdadeira se ambas 𝑃 e 𝑄 tiverem os mesmos valores de verdade (ambas verdadeiras ou ambas falsas), e falsa em todos os outros casos.

𝑝↔𝑞 = (𝑝→𝑞)∧(𝑞→𝑝)

Tabela Verdade Bicondicional

3.5 Tautologias

Uma tautologia é uma proposição composta que é sempre verdadeira, independentemente do valor de verdade das proposições que a compõem.

Em outras palavras, uma tautologia é uma expressão lógica que é verdadeira em todas as situações possíveis.

Para verificar se uma proposição é uma tautologia, você pode construir a sua tabela verdade correspondente. Se, em todas as linhas da tabela, a proposição resultar em “verdadeiro” (V), então ela é considerada uma tautologia.’

Tabela Verdade Tautologia

3.6 Leis de Morgan

As leis de Morgan são um conjunto de regras na lógica matemática que fornecem uma forma de expressar negações de proposições compostas. As leis de Morgan são duas:

1. Primeira Lei de Morgan:A negação de uma conjunção é equivalente à disjunção das negações das proposições individuais.

¬(𝑝∧𝑞)=(¬𝑝)∨(¬𝑞)

1. Segunda Lei de Morgan: A negação de uma disjunção é equivalente à conjunção das negações das proposições individuais.

¬(𝑝∨𝑞)=(¬𝑝)∧(¬𝑞)

3.7 Tabela Verdade em Python

Uma forma maneira de criar tabelas verdade utilizando Python é através da biblioteca ‘truth-table-generator’. Ela permite gerar a tabela verdade de uma proposição com apenas algumas linhas de código e uma sintaxe simples.

Os operações são:

Operadores e suas representações:

• Negação: ‘not’, ‘-’, ‘~’
• Disjunção lógica: ‘or’
• NOR lógico: ‘nor’
• Disjunção exclusiva: ‘xor’, ‘!=’
• Conjunção lógica: ‘and’
• NAND lógico: ‘nand’
• Implicação material: ‘=>’, ‘implies’
• Bicondicional lógico: ‘=’

Vamos a um exemplo simples, a tabela verdade de 𝑃∧𝑄

Outros Exemplo, agora incluindo a disjunção:

Podemos unir o Sympy com a Truth Table Generator, como no exemplo abaixo:

“Se for um dia ensolarado (p) e eu tiver tempo livre (q), então irei à praia (r) ou farei um piquenique (s), mas não farei ambos.”

# Definindo as variáveis simbólicas
p, q, r, s = symbols('p q r s')

# Printando sentenças
display(f'{p}: Se for um dia ensolarado.')
display(f'{q}: e eu tiver tempo livre')
display(f'{r}: então irei à praia')
display(f'{s}: ou farei um piquenique')


# Realizando Calculo
prep = Implies(And(p, q), And(Or(r, s), Not(And(r, s))))

print('\n Preposição completa')
# Pritando Preposição completa
display(prep, 'Se for um dia ensolarado e eu tiver tempo livre, então irei à praia ou farei um piquenique, mas não farei ambos.')

# Tabela Verdade
print('\n Tabela Verdade:')
print(ttg.Truths(['p', 'q','r','s'], ['(p => q)', 'r or s', 'r => s', '(p and q) implies ((r and s) and not(r or s))'], ints=False))

4.0 Portas Lógicas — O Legado de George Boole

O impacto das ideias de Boole não foram compreendidas até cerca de sete décadas após sua morte.

O engenheiro americano Claude Shannon utilizou a “Análise Matemática da Lógica” de Boole para estabelecer os fundamentos dos circuitos de computadores digitais modernos.

Ele percebeu que o sistema binário de dois valores de Boole poderia servir como a base para portas lógicas, dispositivos físicos que operam com base em funções booleanas, no circuito.

Abaixo, a relação entre os Circuítos Lógicas e a Tabela Verdade:

5.0 Considerações Finais

Com isso, encerramos a segunda parte da série de artigos “Aprendendo Matemática com Python”. Nesta edição, irei deixar uma playlist do Youtube sobre Raciocínio Lógico Matemático, que usei como base para a criação do artigo e que recomendo muito!

Além disso, irei deixar outras fontes relevantes para o estudo de Algebra Booliana.

A partir dessa edição, irei estar disponibilizando os Notebooks Jupyter de cada artigo no meu Github, acessa lá!

Curso de RLM:

Outros Links:

History of logic - Aristotle, Syllogism, Deduction

https://www.todamateria.com.br/logica-aristotelica/

https://www.todamateria.com.br/logica-aristotelica/

https://study.com/academy/lesson/aristotelian-logic-aristotles-central-concepts-and-influence.html

https://docs.sympy.org/latest/tutorials/intro-tutorial/printing.html

E por hoje é isso pessoal! Me sigam nas redes:

Linkedin — (https://www.linkedin.com/in/jvroot/)

Github — (https://github.com/JV-root)

Joinha do Corki:

Introdução

Olá, Pessoal! Espero que todos estejam bem!

Hoje estou começando uma nova série de artigos dedicados a um tema que me interessa muito: Performance de Software. É um assunto sobre o qual encontro poucos materiais na internet, mas que é de extrema importância, especialmente no contexto de sistemas de grande escala.

Neste artigo inicial, meu objetivo é apresentar uma abordagem mais teórica, fornecendo uma visão geral sobre performance. Porém, nas próximas edições, pretendo trazer um viés mais prático.

Sem mais delongas, vamos começar! :)

1.1 Contextualização

Os testes de performance de software desempenham um papel fundamental no cenário atual, caracterizado pela rápida evolução tecnológica e pela intensa concorrência entre as empresas.

Nesse contexto, as organizações enfrentam o desafio contínuo de entregar produtos e serviços de alta qualidade, ao mesmo tempo em que buscam atender às expectativas dos clientes.

1.2 Cenário Real

“ […] O início das vendas online dos ingressos para o Lollapalooza Brasil foi marcado pela lentidão do site oficial. A partir da 0h, quando teve início o comércio, diversos usuários enfrentaram problemas com o sistema, que caía e data erro na hora de processar a compra. Outros tiveram dificuldade de acessar o site pelo esquema de senhas organizado previamente […] “

Casos como esse reforçam a relevância dos testes de performance no desenvolvimento de sistemas que precisam lidar com grandes volumes de acesso. A falha enfrentada na venda de ingressos poderia ter sido evitada — ou ao menos mitigada — com a realização de testes adequados que simulassem cenários de carga e estresse.

A seguir, destacam-se os principais benefícios proporcionados por uma estratégia eficaz de testes de performance.

1.3 Benefícios de Testes de Performance

Ao avaliar velocidade, escalabilidade e a estabilidade de aplicativos, sites e outros produtos digitais, os testes de performance desempenham um papel fundamental na identificação e na resolução de problemas antes que impactem os usuários finais.

As análises dos dados resultantes dos testes revelam oportunidades de melhoria, permitindo a implementação de ações corretivas e ajustes durante o desenvolvimento. Isso previne indisponibilidade, falhas e outros problemas relacionados ao desempenho da aplicação.

Essa abordagem não apenas aumenta a satisfação do cliente, mas também fornece respostas essenciais para perguntas-chave, como:

“Minha aplicação opera com eficiência?”

“Qual o seu desempenho em diferentes cenários, como X ou Y?”

2. Cenários de Teste de Performance

Quando pensamos em cenários para Testes de Performance, existem dois modelos:

Ambos os cenários são essenciais para garantir a eficiência e o bom funcionamento do software. O teste “End to End” avalia o desempenho geral do sistema, enquanto o teste isolado permite a otimização de componentes específicos.

3. Tipos de Teste de Performance

Existem diversos tipos de abordagens para testes de desempenho, mas, de modo geral, concentram-se nos seguintes tipos:

3.1 Teste de Carga

Foca na capacidade de um sistema em lidar com crescentes níveis de carga, decorrentes de transações geradas por um número gradualmente maior de usuários ou processos controlados ou concorrentes.

Esse tipo de teste é frequentemente utilizado no processo de planejamento de capacidade, para garantir que um sistema possa lidar com o crescimento para níveis especificados de tráfego simultâneo.

3.2 Teste de Estresse

O teste de estresse se concentra na capacidade de um sistema ou componente em lidar com picos de cargas que estão no limite ou além do previsto ou especificado.

Além disso, pode ser usado também para avaliar a capacidade do sistema em lidar com recursos de infraestrutura reduzidos, como capacidade de processamento, largura de banda e memória.

3.3 Teste de Pico

O teste de pico visa testar a capacidade máxima de uma aplicação em lidar com uma carga de trabalho muito alta em um curto período de tempo.

Esse teste ajuda a determinar se o desempenho do sistema se deteriora quando há um aumento súbito da carga. Outro objetivo desse teste é determinar o tempo de recuperação do sistema. Entre dois picos consecutivos de carga do usuário, o sistema precisa de algum tempo para se estabilizar. Esse tempo de recuperação deve ser o mais baixo possível.

3.4 Teste de Resistência

Verifica a capacidade de um sistema de continuar operando de forma estável sob uma carga de trabalho constante, geralmente por um período prolongado.

O objetivo é avaliar a capacidade do sistema de lidar com uma carga constante (steady load), sem apresentar problemas de recursos, tais como vazamentos de memória (memory leaks), sobrecarga de conexões de banco de dados (database connection overload) ou outros tipos de falhas que possam afetar negativamente a performance (performance) do sistema e causar interrupções (downtime).

3.5 Teste de Escalabilidade

Determina a capacidade do sistema de expandir para atender a requisitos futuros de eficiência, sem violar os requisitos de performance especificados. Identifica os limites de escalabilidade e possibilita ajustes no ambiente de produção.

O teste de escalabilidade envolve a simulação de diferentes cargas de trabalho para avaliar como o sistema se comporta à medida que a demanda aumenta. Este processo permite identificar possíveis gargalos e pontos de falha, garantindo que o sistema possa ser ajustado adequadamente para suportar crescimento sem perda de performance.

4.0 Como avaliar um Teste de Performance?

Durante um teste de performance, é essencial analisar diversas métricas para avaliar o desempenho do sistema. Algumas das principais incluem:

4.1 Tempos de Resposta

O tempo total decorrido desde a solicitação do usuário até a entrega da resposta de uma requisição é uma medida comum de desempenho de uma aplicação. Essa medida é geralmente expressa em milissegundos, de acordo com o padrão de mercado.

4.2 Vazão (Throughput)

A vazão (throughput) mede a quantidade de requisições que um sistema é capaz de processar dentro de um determinado período de tempo. Essa métrica geralmente é representada em requisições por segundo (RPS) ou transações por segundo (TPS).

É importante que o gráfico de vazão consiga acompanhar o crescimento da carga de usuários para garantir que o sistema seja capaz de lidar com o aumento do tráfego.

Caso a vazão não aumente proporcionalmente à carga de um usuários pode ser um indicativo de gargalo na performance que precisa ser investigado.

Por exemplo, um aumento repentino na vazão pode parecer uma melhora na performance, mas pode, na verdade, indicar um pico de erros.

Respostas de erro, por serem processadas mais rapidamente que o fluxo normal da aplicação, podem gerar uma falsa sensação de ganho, mascarando problemas críticos no sistema.

4.3 Percentil

O percentil é uma medida estatística que divide um conjunto de dados ordenados em cem partes iguais, permitindo a análise da distribuição dos valores — como os tempos de resposta — de forma detalhada.

Por exemplo, o percentil 50 (P50) corresponde à mediana, indicando que 50% das observações estão abaixo (ou iguais) a esse valor e os outros 50% estão acima. Já percentis como o P90 ou P95 mostram os valores abaixo dos quais estão, respectivamente, 90% e 95% dos dados.

Essa abordagem é especialmente útil em testes de performance, pois permite identificar limiares críticos de tempo de resposta e avaliar a experiência da maioria dos usuários, mesmo em cenários com valores extremos (outliers).

4.4 Taxa de Erros

A taxa de erros é um indicador que representa a porcentagem de requisições que resultaram em falhas em relação ao total de requisições realizadas durante um teste. Esse valor é essencial para avaliar a confiabilidade da aplicação sob carga.

Em aplicações web, toda requisição enviada ao servidor recebe uma resposta na forma de um código de status HTTP, que indica o resultado do processamento.

Esses códigos são agrupados em categorias conforme o intervalo numérico, permitindo a rápida identificação do tipo de resposta:

A taxa de erros geralmente considera os códigos 4xx e 5xx como indicadores de falha, sendo especialmente crítica em testes de performance, pois pode apontar gargalos ou instabilidades sob carga elevada.

É importante ressaltar que esses códigos não informam o causador do problema, mas orientam a investigação do erro.

5.0 Fontes e Referências

Minha principal referência na criação deste artigo é a certificação de Testes de Performance da instituição ISTQB (International Software Testing Qualifications Board).

Para obter informações mais detalhadas, recomendo dar uma olhada na documentação oficial por meio do seguinte link:

Certified Tester Performance Testing (CT-PT)

Além disso, um ótimo site para aprender sobre performance é o Blazemeter:

Performance Testing vs. Load Testing vs. Stress Testing | BlazeMeter by Perforce

E por hoje é isso pessoal! Me sigam nas redes:

Linkedin — (https://www.linkedin.com/in/jvroot/)

Github — (https://github.com/JV-root)

1.0 Introdução

Fala, pessoal! Sejam muito bem-vindos à mais uma etapa da nossa jornada de aprendizado de Matemática com Python! Estou empolgadíssimo com os temas que vamos explorar desta vez.

Sem mais enrolação, vamos nessa!

2.0 Potenciação e Radiciação

Continuando nossa jornada pelos conceitos fundamentais da matemática, quero começar este capítulo dando uma olhada mais de perto nos temas potenciação e radiciação.

Potenciação é uma operação matemática que envolve a multiplicação repetida de um número por ele mesmo, elevado a uma certa potência. O número que está sendo multiplicado é chamado de base, e o expoente indica quantas vezes a base deve ser multiplicada por si mesma.

O resultado dessa operação é chamado de potência. Por exemplo, 2³ significa 2 multiplicado por ele mesmo três vezes (2 * 2 * 2), resultando em 8.

Já a Radiciação é uma operação matemática que representa a extração de raiz de um número. A raiz é o número que, quando elevado a um certo expoente, produz o número original. O símbolo radical (√) é comumente usado para indicar a operação de radiciação.

O número que está dentro do símbolo radical é chamado de radicando. Por exemplo, √9 é igual a 3, pois 3 elevado ao quadrado (3²) resulta em 9.

Vamos a um pouco de história.

2.1 Arquimedes e o Sol

A ideia de elevar um número a uma potência tem raízes antigas, mas os registros históricos indicam que os babilônios, por volta de 2000 a.C., já utilizavam técnicas de potenciação. Porém, a formalização desses conceitos ocorreu mais tarde, com os gregos antigos.

Reza a lenda em que Arquimedes em seus estudos empreendeu o desafio de calcular quantos grãos de areia seriam necessários para preencher o Universo. Esta questão, por mais peculiar que pareça, era fundamental para Arquimedes em sua época. Na concepção daquele período, o Universo era considerado um sistema de esferas, todas compartilhando o mesmo centro: o Sol. Os planetas eram fixados na superfície de cada esfera.

Realizando cálculos relacionados aos diâmetros dessas esferas, Arquimedes determinou o volume do Universo, bem como o volume médio de um grão de areia. Ao final da divisão, o resultado obtido era um número imenso. Para lidar com isso, Arquimedes desenvolveu uma tabela e introduziu algarismos especiais chamados “miríades,” que correspondem aos expoentes modernos, simplificando os cálculos com números de grande magnitude.

2.2 Potenciação em Python

As operações envolvendo potenciação podem ser aplicadas de maneira bem simples no python, no geral sem utilizar nenhuma biblioteca adicional. O operador nesse caso, é o **. Dessa forma, para elevar um dado valor A a uma potência B, basta executar:

# Definindo valores
x = 2
y = 5

# Operações com Potências
x_quadrado = x ** 2
x_cubo = x ** 3
x_quarta = x ** 4
x_elevado_y = x ** y

print(f'Resultado da operação ao quadrado = {x_quadrado}')
print(f'Resultado da operação ao cubo = {x_cubo}')
print(f'Resultado da operação a quarta = {x_quarta}')
print(f'Resultado da operação X elevado a Y = {x_elevado_y}')

"""
Resultado da operação ao quadrado = 4
Resultado da operação ao cubo = 8
Resultado da operação a quarta = 16
Resultado da operação X elevado a Y = 32

"""

A operação de potenciação pode ser feita também utilizando a função pow da biblioteca Math:

from math import pow

# Definindo valores
x = 2
y = 5

# Operações com Potencias
x_quadrado = pow(x, 2)
x_cubo = pow(x, 3)
x_quarta = pow(x, 4)
x_elevado_y = pow(x , y)

print(f'Resultado da operação ao quadrado = {x_quadrado}')
print(f'Resultado da operação ao cubo = {x_cubo}')
print(f'Resultado da operação a quarta = {x_quarta}')
print(f'Resultado da operação X elevado a Y = {x_elevado_y}')


"""
Resultado da operação ao quadrado = 4.0
Resultado da operação ao cubo = 8.0
Resultado da operação a quarta = 16.0
Resultado da operação X elevado a Y = 32.0

"""

2.3 Radiciação

A operação de radiciação (ou também conhecida como Raiz) pode ser feita utilizando a própria operação de Potenção. Ou seja, para se obter a Raiz Quadrada de um dado valor X, basta que seja elevado a 1/2.

Porém é importante ressaltar que, neste caso, a divisão a ser usada na potência não pode ocorrer com valores inteiros. Ou seja, na linguagem Python, 1/2 = 0. (isso faria qualquer valor diferente de 0 elevado a essa potencia resultar em 1) e 1.0 / 2 = 0.5.

Vamos ao exemplo:

# Definindo valores
x = 256

# Operações de Radiciação
x_raiz_quadrada = x ** (1 / 2)
x_raiz_cubica = x ** (1 / 3)
x_raiz_quarta = x ** (1 / 4)

print(f'Resultado da Raiz Quadrada de X = {x_raiz_quadrada}')
print(f'Resultado da Raiz Cubica de X = {x_raiz_cubica}')
print(f'Resultado da Raiz Quarta de X = {x_raiz_quarta}')

"""
Resultado da Raiz Quadrada de X = 16.0
Resultado da Raiz Cubica de X = 6.3496042078727974
Resultado da Raiz Quarta de X = 4.0


"""

Antes de mergulharmos em outro tópico, vale a pena ressaltar de forma clara a lei da Exponenciação.

Essencialmente, a lei da Exponenciação (ou Potenciação) estipula que, ao multiplicar duas potências com a mesma base, a soma dos expoentes é necessária. Matematicamente, para números reais A, B, e C, a expressão A^(B + C) equivale a A^B * A^C.

Essa regra simplifica a multiplicação de potências com a mesma base, adicionando uma maior eficiência à manipulação algébrica.

Aplicando em Python, temos o seguinte código:

print(5 ** 5)
print(5 * 5 * 5 * 5 * 5)

print('----------------------------------------------------')

print(5 ** 2 * 5 ** 5)
print(5 ** (2 + 5))


"""
3125
3125
----------------------------------------------------
78125
78125

"""

3.0 Sequência das Operações em Python

Um assunto que considero extremamente importante etneder em Python é a sequência de execução de operações matemáticas. A linguagem segue uma ordem predefinida para realizar várias operações em uma única linha de comando. Essa ordem é a seguinte:

• Parênteses;
• Potenciação;
• Multiplicação;
• Divisão;
• Adição;
• Subtração;

Ou seja, dada a seguinte equação:

O Python iria realizá-la da seguinte forma:

• 3 * 256 = 768;
• 768 / 8 = 96;
• 2 + 96 = 98;
• 98–2 = 96.

Se a mesma operação fosse feita com parenteses, sua sequência de execução mudaria, como no exemplo abaixo:

• 2 + 5 = 5;
• 8–2 = 6;
• 5 * 256 = 1280;
• 1280 / 6 = 213.33;

Uma forma de memorizar a ordem de execução de operações matemáticas em python, é utilizando de uma regra em inglês chamada PEMDAS;

• Parentheses;
• Exponents;
• Multiplication;
• Division;
• Addition;
• Subtraction;

Então, para lembrar da sequência de execução, lembre de um panda fofinho:

4.0 Equações em Python

Como último, gostaria de falar um pouco sobre como representar equações em Python. Uma das ferramentas mais utilizadas no mundo da matemática para representar equações matemáticas no computador é o Latex.

O LaTeX, criado por Leslie Lamport na década de 1980, é uma linguagem de marcação amplamente utilizada para representar equações matemáticas em documentos científicos. Diferentemente de processadores de texto convencionais, o LaTeX oferece formatação automática, permitindo que os usuários foquem no conteúdo.

Essa ferramenta é essencial para acadêmicos e cientistas, proporcionando qualidade tipográfica superior e facilitando a expressão de equações complexas. Além de seu uso em notação matemática, o LaTeX é prevalente na criação de artigos científicos, teses e apresentações em ambientes acadêmicos, proporcionando consistência e clareza na comunicação de ideias e descobertas.

4.1 Aplicação em Python

Inicialmente, iriei mostrar algumas equações e funcionalidades básicas do Latex em python, e conforme a evolução dos tópicos ao longo dos artigos irei mostrando novas.

para representar as equações, iremos utlizar o módulo Python chamado IPython.display que faz parte da biblioteca IPython. Além disso, iremos importas as seguintes funções em nosso código: display, Math, Latex.

# Importando Bibliotecas
from IPython.display import display, Math, Latex

A partir dessa linha de código, podemos utilizar as funções para plotar equações matemáticas utilizando a função display, como no exemplo:

# Plotando a primeira equação em Python.
display('5 + 5 = 10')

Um outro exemplo interessante, é utilizar o próprio Python para calcular o resultado da operação:

# Utilizando o Python para calcular o resultado da equação.
display('10 + 5 = ' + str(10 + 5) )

Agora, vamos utilizar variáveis para armazenar valores que serão usados nas equações. Uma forma de fazer isso é semelhante com a funcionalidade f-string utilizada no print:

# F-string
ola = 'Olá, Mundo!'
print(f'{ola}')

"""

Olá, Mundo!

"""

Aplicando a função display:

# Definindo valores
x = 10
y = 5

# Plotando a equação.
display(Math('%g + %g = %g' %(x, y, x + y)))

Agora vamos ver como fica fração utilizando o Latex:

# Definindo valores
x = 10
y = 5

# Plotando a equação.
display(Math('\\frac{%g}{%g} = %g' %(x, y, x / y)))

Repare que inicialmente é algo bem intuitivo, passamos a função ‘frac{}{}’ com seus respectivos valores dentro das chaves. Um detalhe importante de mencionar é que no caso do Latex aplicado ao Python, é preciso passar duas \ (barras para a esquerda) antes de utilizar essas funções.

Por último, vamos ver como podemos representar a potenciação no Latex com python:

# Definindo valores
x = 10
y = 5

# Plotando a equação
display(Math('%g ^ %g = %g' %(x, y, x * y)))

O símbolo ‘^’ (para os mais intimos a casinha hahahaha) é utilizado para representar a potenciação.

5.0 Considerações Finais

Com isso, encerramos a segunda parte da série de artigos “Aprendendo Matemática com Python”. Como de costume, ao término, apresentarei alguns exercícios e curiosidades para que você possa aprimorar ainda mais seus conhecimentos no assunto.

Para o desafio de hoje, proponho uma atividade envolvendo LaTeX. A tarefa consiste em plotar as seguintes equações:

A solução para os dois exercícios irei deixar no link do Colab com o conteúdo dessa edição.

Além dos exercícios, deixo alguns link do Khan Academy sobre os assuntos citados:

Khan Academy:

• Raízes, potências e notação científica | Pré-álgebra | Khan Academy
• PEMDAS Khan Academy
• Potenciação Khan Academy

Curiosidades

• O desafio de Arquimedes para contar grãos de areia — IMPA — Instituto de Matemática Pura e Aplicada
• Potência: História da descoberta do conceito

Link para o Colab:

https://colab.research.google.com/drive/1WrdKRO0TNz6IHvdGklg2xmJJh6354DJP#scrollTo=LwREAlBOmSjX

E por hoje é isso pessoal! Me sigam nas redes:

Linkedin — (https://www.linkedin.com/in/jvroot/)

Github — (https://github.com/JV-root)

1. Introdução

Fala, pessoal! Estou empolgadíssimo em fazer minha primeira publicação no Medium, e para o tópico inaugural, decidi abordar algo que sempre me causou dificuldades: Matemática!

Resumindo a minha trajetória, desde os primeiros anos da escola, a matemática e eu éramos quase como água e óleo. Cada equação e teorema pareciam o fim do mundo (nada exagerado, não? hahahahaha), e essa dificuldade só crescia com o passar do tempo gerando uma ansiedade só de ter que fazer uma conta de cabeça.

No entanto, tudo começou a mudar quando me apaixonei pela Estatística e Ciência de Dados e, curiosamente, quando me deparei com um livro que mudaria o jogo para mim: “O Livro da Matemática”. Esse livro não é como os livros maçante de matemática; ele é repleto de ilustrações didáticas e com explicações de forma clara e envolvente.

E foi aí que começou a mágica: A matemática, antes um gerador de ansiedade, passou a se transformar em um fascinante quebra-cabeça esperando para ser resolvido, quase como um Tetris. A matemática aplicada, especialmente na Estatística e Ciência de Dados, revelou uma nova dimensão para mim, uma em que eu podia ver a beleza das fórmulas e dos números.

Desde então, venho estudando matemática e pensando em como compartilhar tudo que venho aprendendo, e qual seria a melhor maneira de fazer isso se não demonstrando com Python, uma linguagem de programação incrível, e amplamente utilizada na área de dados?

Para dar início à nossa série, vamos começar pelo básico: Aritmética!

2. Aritmética

Basicamente, as operações aritméticas, fundamentais nas equações matemáticas, têm uma história que remonta a tempos antigos, evidenciada pelo Papiro de Rhind, datado por volta de 1550 a.C. Nesse manuscrito egípcio, registram-se as operações básicas como adição, subtração e multiplicação, destacando a importância desses conceitos desde os primórdios da matemática.

2.1 Operações Aritméticas

2.2 Adição

Do mesmo modo que aprendemos na matemática do ensino fundamental, em Python, utilizamos o sinal (+) para realizar a adição de dois números ou mesmo de duas variáveis contendo valores quaisquer. Veja o exemplo abaixo:

2.3 Subtração

O procedimento é semelhante para a subtração, empregando o sinal (-) para subtrair um valor de outro. Veja o exemplo:

2.4 Multiplicação

A representação da multiplicação em Python é diferente do que aprendemos no ensino fundamental, onde costumamos usar a letra (X) ou, até mesmo em algumas linguagens de programação, onde se usa o símbolo (^). Em vez disso, em Python, a multiplicação é representada pelo asterisco (*). Vejamos os exemplos:

2.5 Divisão

O operador de divisão é representado pela barra inclinada para a direita (/). Exemplo:

2.5.1 Resto da Divisão

O resto da divisão, muitas vezes denotado pelo símbolo %, é o valor que permanece quando um número não é completamente divisível por outro. Em outras palavras, se você dividir um número a por outro número b, o resto da divisão é o que sobra.

3.0 Conjuntos Numéricos

Um outro tema que considero de suma importância para os fundamentos de matemática são os Conjuntos Numéricos, que basicamente consistem em agrupamentos de números com características em comuns.

No contexto de Python, encontramos diversos tipos desses conjuntos, com destaque para o conjunto dos números inteiros (representados como “int”) e o conjunto dos números reais (denominados como “float”). Em um outro artigo irei abordar como que o Python lida com números por baixo dos panos.

Os números inteiros abrangem tanto os positivos quanto os negativos, incluindo o zero. Por outro lado, os números reais englobam aqueles que podem ser expressos como frações, onde tanto o numerador quanto o denominador são números inteiros.

Existem diversos tipos de conjuntos numéricos, mas neste artigo, meu foco principal será nas operações envolvendo esses conjuntos. No entanto, deixo disponível o seguinte link que contém uma explicação detalhada sobre cada um deles.

3.1 Sympy

Para realizar as principais operações de conjuntos em Python, podemos utilizar a função integrada Set. Porém, eu iriei demonstrar uma abordagem alternativa utilizando a biblioteca Sympy.

O Sympy é uma biblioteca em Python voltada para álgebra simbólica. Ao contrário da computação numérica, que lida com valores numéricos, a álgebra simbólica manipula expressões matemáticas de forma simbólica, preservando variáveis como símbolos em vez de substituir por valores específicos.

Com o Sympy, você pode realizar operações algébricas, resolver equações, simplificar expressões, calcular derivadas e integrais, entre outras tarefas, mantendo os resultados em termos de símbolos matemáticos.

Antes de tudo, precisamos nos certificar se o Sympy está instalado. Caso não tenha, você pode instalar utilizando o pip em seu terminal:

Após a instalação, importe o Sympy em seu script ou ambiente de desenvolvimento favorito, eu recomendo o Jupyter Notebook:

Pronto! Agora podemos utilizar as principais funcionalidades da biblioteca Sympy!

3.2 O Diagrama de Venn

Antes de irmos para as operações, assim como com aritmética, lá vai um pouco de história:

Em 1880, o matemático britânico John Venn apresentou a ideia do diagrama de Venn no artigo “On the Diagrammatic and Mechanical Representation of Propositions and Reasonings” [Sobre a representação diagramática e mecânica de proposições e raciocínios]. O diagrama de Venn é um modo de agrupar coisas em cículos (ou outras formas curvas) sobrepostos para mostrar a relação entre eles.

O diagrama de Venn pode ser usado (dentre outras funcionalidades) para representar as operações de conjuntos. Por exemplo, a união de dois conjuntos A e B pode ser representada por um diagrama de Venn com dois círculos, onde cada círculo representa um conjunto.

3.3 Operações com Conjuntos

Explorando as operações fundamentais de conjuntos, neste artigo irei focar nas quatro principais operações, cuja descrição encontra-se ilustrada na imagem a seguir:

O diagrama de Venn é uma ferramenta visual bem interessante que pode ser usada para representar conjuntos numéricos e suas operações.

3.4 União

A operação de união em conjuntos numéricos é uma forma de combinar todos os elementos distintos de dois conjuntos em um único conjunto. Se tivermos dois conjuntos A e B, a união deles, denotada por A∪B, consiste em todos os elementos que pertencem a pelo menos um dos conjuntos.

Aplicando em Python:

Representação em Diagrama de Venn

3.5 Intersecção

A interseção em conjuntos numéricos é uma operação que envolve encontrar os elementos comuns a dois ou mais conjuntos. Pense nos conjuntos como grupos de números. Se você tem dois conjuntos, A e B, a interseção deles, denotada por A ∩ B, é o conjunto de todos os elementos que pertencem tanto a A quanto a B.

Aplicando em Python:

Representação em Diagrama de Venn:

3.6 Diferença

A diferença entre conjuntos numéricos é uma operação que resulta em um conjunto contendo todos os elementos de um conjunto (A) que não estão presentes em outro conjunto (B). Pode ser denotada por A−B ou A\B.

Aplicando em Python:

Representação em Diagrama de Venn:

3.6 Diferença Simétrica

A diferença simétrica entre dois conjuntos numéricos, denotada por A Δ B, é um conceito que engloba os elementos exclusivos de cada conjunto, excluindo aqueles que são comuns a ambos. Em outras palavras, a diferença simétrica inclui todos os elementos que estão em A e não em B, juntamente com todos os elementos que estão em B e não em A.

Representação em Diagrama de Venn:

4.0 Considerações Finais

Com isso, concluímos a primeira parte da série de artigos “Aprendendo Matemática com Python”. Como bônus, ao final de cada artigo, apresentarei alguns exercícios e curiosidades para que você possa aprofundar seus conhecimentos no tema. Para este artigo, deixo uma seleção de exercícios na Khan Academy relacionados aos tópicos abordados.

• Khan Academy
• Notação básica de conjunto (prática) | Khan Academy

Uma curiosidade maneira, é que os Diagramas de Venn mostrados nesse artigo foram todos feito utilizando Python. Caso queiram saber um pouco mais sobre, recomendo a biblioteca MatplotLib_Venn.

matplotlib-venn

E por hoje é isso pessoal! Me sigam nas redes:

Linkedin — (https://www.linkedin.com/in/jvroot/)

Github — (https://github.com/JV-root)