Forem: Marcos Mendes

Why Rust it's so good?

Marcos Mendes — Thu, 26 Dec 2024 13:16:22 +0000

Why is Rust such a beloved programming language?

If you've heard of Rust, you might know it's one of the most loved programming languages among developers. But what makes Rust win over so many devs? There are several reasons for this, such as:

Efficient memory management: Rust provides extremely effective control, leading to fewer bugs and security vulnerabilities.
Active and welcoming community: The Rust community is renowned for supporting new developers on forums and social platforms like Reddit and Discord.
High-quality documentation: Learning Rust is made easier by its detailed and accessible documentation.
Concurrency support: Rust simplifies the use of multiple threads safely and efficiently.

Rust for Beginners?

Despite the advantages mentioned above, Rust is not the most recommended language for beginners. Its ownership system and safety checks require a solid understanding of programming basics, making it better suited for those with prior experience.

A highly recommended resource to ease the learning process is The Rust Programming Language book, also known as The Rust Book.

Link: https://doc.rust-lang.org/book/

Let’s explore these points in more detail.

Memory Management

Rust excels at preventing common issues like memory leaks. During compilation, Rust performs strict checks, catching many errors before the program runs.

One reason for this safety is the concept of ownership:

Every value in Rust has a single owner.
When this owner goes out of scope, the memory is automatically released.

This model eliminates the need for traditional garbage collectors, resulting in more efficient resource management.

Performance

Rust offers low-level memory control similar to languages like C and C++ but with the safety of a modern language.

This allows programs written in Rust to be fast and efficient.
The Rust compiler uses LLVM to generate highly optimized code, achieving performance comparable to C.

Concurrency
Rust makes writing concurrent code easier by including safety checks at compile time.

These mechanisms prevent issues like race conditions and make leveraging the power of multicore CPUs safer and more intuitive.

Tools and Ecosystem

Rust comes with powerful tools that enhance developer productivity:

Compiler: Provides clear error messages, simplifying debugging and problem-solving.
Cargo: Rust's package manager makes building projects and managing dependencies straightforward, functioning similarly to NPM for Rust.

Active Community

As an open-source project, Rust benefits from contributions from developers worldwide.

The community stands out for creating libraries and tools that enrich the ecosystem.
Forums and platforms like Reddit and Discord offer support for newcomers.

Real-World Use Cases

Major companies like Mozilla, Dropbox, and Cloudflare have adopted Rust for their projects. They have reported several benefits, including:

Enhanced security.
Improved performance.
Easier code maintenance.

Others companys that use Rust ->

Code Examples

Memory Management with Ownership
Here's how the concept of ownership works in practice:

Performance: Counting from 1 to 1 million
A simple example demonstrating Rust's efficiency:

Concurrency with Threads
Calculate the sum of numbers in parallel safely:

Using Cargo to Create and Run a Project
Creating and running a new project is simple:

Conclusion
Rust combines safety, performance, and productivity in a modern programming language. Its robust ecosystem and engaged community make learning it more accessible to those with some programming experience. Although challenging at first, Rust's benefits make the effort highly rewarding.

Follow me on social media:

Github: https://github.com/iamdevmarcos
Linkedin: https://www.linkedin.com/in/iamdevmarcos/

React Hydration Explained

Marcos Mendes — Tue, 19 Nov 2024 17:17:20 +0000

Definition of Hydration by Dan Abramov (Create React App and Redux): "Hydration is like watering 'dry' HTML with the 'water' of user interactivity and event handlers."

Hydration is an advanced and fundamental topic for better understanding how React works. Before diving deeper into this concept, let’s briefly review some important topics:

1. Client-Side Rendering (CSR)

Client-side rendering occurs when all pages are loaded and rendered directly in the browser using JavaScript. In this way, the browser is responsible for handling all requests (data fetching), managing loading states, and other interactions.

2. Server-Side Rendering (SSR)

In server-side rendering, pages are generated on the server using JavaScript and sent as HTML to the client. This process optimizes data fetching on the server, improving the user experience. In SSR, the initial HTML is loaded while the JavaScript needed for interactivity is loaded in the background.

What is React Hydration?

Hydration is the process of taking pre-rendered HTML on the server and making it interactive in the browser. In other words, React checks the existing HTML and associates the necessary JavaScript to activate the components, enabling interactivity.

This speeds up page loading since the static content (initial HTML) is quickly loaded while interactivity is enabled afterward.

It is worth noting that hydration does not directly apply to libraries or frameworks that function only on the client (client-only), such as React when used exclusively on the client side.

Why don’t client-only frameworks have Hydration?

Client-only frameworks or libraries, such as React in a pure CSR model, render pages directly in the browser, generating the DOM from scratch with JavaScript. In this case, there is no pre-rendered HTML from the server to be “hydrated.”

Thus, client-only frameworks use a process known as Client-Side Rendering (CSR), and the concept of hydration does not apply to them.

Explained simply

Imagine you have a page ready and already rendered with all visible content, but it does nothing when you click buttons. The role of React Hydration is to bring this page to life, connecting what you see on the screen to the code responsible for making it interactive.

When React performs the hydration process, it "animates" the page, linking the visible components to the code, making buttons and other elements functional and interactive in the browser.

Hydration in React 19

In React 19, the hydrate method (responsible for hydration) was removed and replaced with the hydrateRoot method. Below is an example of how it was before and how it is now:

Before:

import { hydrate } from 'react-dom';
hydrate(<App />, document.getElementById('root'));

After:

import { hydrateRoot } from 'react-dom/client';
hydrateRoot(document.getElementById('root'), <App />);

This update was introduced by the React team to improve the hydration process and compatibility with new APIs in React 19.

Main differences:

hydrate (React 18 and earlier): Starts the hydration process at the point where the server left off with the HTML.
hydrateRoot (React 18 and later): Replaces hydrate and provides a more modern and flexible API, especially to support features like streaming and transitions in React.

That’s basically it about hydration ;)

Content Delivery Network Explained !

Marcos Mendes — Sun, 21 Apr 2024 00:09:52 +0000

Summary

🇺🇸 English
🇧🇷 Portuguese

Why does a CDN exist?

Let's imagine we are an Amazon Prime user, located in Sao_Paulo/Brazil, while Amazon is based in the United States.

Given this setup, all of Amazon's movies and series are stored in the United States, so every time you want to watch something, you will have to make a request over a long distance to Amazon in the United States.

At first glance, we can see that using this method is not scalable and comes with several problems, such as:

1 - Latency
2 - Distributing data at speed over very long distances
3 - Data distribution capacity

What exactly is a CDN?

A CDN or Content Delivery Network is a distributed network of proxy servers.

The idea is that the content from Amazon Prime, which is stored in the United States, is replicated across various proxy servers distributed worldwide.

In practice, when someone located in Sao_Paulo/Brazil, for example, wants to watch a movie or series, a request will be made to the nearest CDN instead of to Amazon’s origin servers.

This way, latency is greatly reduced, and data distribution happens much faster.

Functional requirements of a CDN:

Retrieve: Needs to be able to request content from the origin server
Request: Must be able to respond to the user when they request content.
Delivery: If the CDN is a Push Model, the origin server needs to be able to push content to the CDN
Search: Needs to be capable of searching content within its infrastructure
Update: Proxies should be able to update each other
Delete: Must be capable of clearing cache, if necessary.

Non-functional requirements:

Performance
Availability
Scalability
Readability
Security

How does the CDN work between the Origin and the Client?

To simplify, the Client (User) makes a request, this request communicates with the nearest CDN, if the content is already saved in cache, the CDN returns the response to the user and completes the request.

If it is new content that is not stored in Cache, the CDN communicates with the Origin Servers to search for the new content, and the origin server delivers this content back to the CDN, which then delivers the content to the user.

Image below for better understanding:

Well, this is a very simple explanation of how a CDN works and what it is, there are several other topics we can delve into to understand more about CDNs.

Porque uma CDN existe?

Vamos imaginar que somos um usuário da Amazon Prime, e estamos localizados em Sao_Paulo/Brazil e a Amazon está localizada nos Estados Unidos.

Dado essa ideia, todos os filmes e series da Amazon, estão armazenados nos Estados Unidos, então toda vez que voce quiser assistir algo voce vai ter que fazer uma requisição de uma longa distancia para a Amazon que está nos estados unidos.

A primeira vista, já percebemos que usar essa forma não é escalável e tem vários problemas, tais como:

1 - Latência
2 - Distribuir dados com velocidade entre distancias muito longas
3 - Capacidade de distribuição de dados

O que é uma CDN de fato?

Uma CDN ou Content Delivery Network é uma rede distribuída de servidores proxy.

A ideia é que o conteúdo da Amazon Prime que está nos Estados Unidos, seja replicada em vários servidores proxy distribuídos no mundo inteiro.

Na pratica, quando alguém que estiver localizado em Sao_Paulo/Brazil por exemplo, quiser assistir um filme ou serie, será realizada uma requisição para uma CDN que estiver mais próxima do usuário, ao invés de fazer uma requisição para os servidores de origem da Amazon.

Desse modo, a latência é muito menor e a distribuição de dados acontece muito mais rápido.

Requisitos funcionais de uma CDN:

Retrieve: Precisa ser capaz de solicitar conteúdo do servidor de origem
Request: Precisa ser capaz de responder ao usuário quando ele solicitar conteúdo.
Delivery: Caso a CDN seja uma Push Model, o servidor de origem precisa ser capaz de dar push no conteúdo para a CDN
Search: Precisa ser capaz de buscar conteúdo dentro da infra da mesma
Update: Proxy's devem ser capazes de fazer update entre si
Delete: Deve ser capaz de limpar cache, caso necessário.

Requisitos não funcionais:

Perfomance
Disponibilidade
Escalabilidade
Legibilidade
Segurança

Como a CDN funciona entre o Origin e o Client ?

Para simplificar, o Client (Usuário) faz uma requisição, essa mesma requisição se comunica com a CDN mais próxima, se o conteúdo já estiver salvo em cache, a CDN devolve a resposta para o usuário e finaliza a requisição.

Caso seja um conteúdo novo que não esteja armazenado em Cache, a CDN se comunica com os servidores de Origem (Origin Server) para buscar pelo novo conteúdo, e o origin server devolve esse conteúdo para a mesma, e a CDN devolve o conteúdo para o usuário.

Imagem abaixo para melhor entendimento:

Bom isto é uma explicação bem simples de como funciona e o que é uma CDN, existem vários outros tópicos que podemos nos aprofundar para entendermos mais sobre a CDN.

Test-Driven Development

Marcos Mendes — Thu, 26 Oct 2023 16:50:12 +0000

Summary

🇺🇸 English
🇧🇷 Portuguese

What's TDD ?

TDD or Test-driven development it's a software development practice that emphasizes creating automated tests before writing the actual code. The TDD process follows a repetitive cycle of three steps:

Write a test: Initially, you write an automated test that describes the behavior you want to implement in the code. This test typically fails initially because the functionality is not yet implemented.
Write code that satisfies the test: Next, you write the production code needed to make the test pass. The goal is to make the code pass the test and nothing more. This promotes incremental development and a focus on the requirement.
Refactor the code: After making the test pass, you can refactor the code, improving its structure and quality without changing its external behavior. Existing tests help ensure that changes do not break existing functionality.

The TDD cycle is repeated multiple times, with each new test covering a specific aspect of the functionality being developed. This ensures comprehensive testing of the code and that the functionality meets the established requirements. TDD also promotes the creation of a robust set of automated tests that can be run regularly to verify code integrity.

TDD is often associated with agile software development practices and is considered an effective approach to improving code quality and maintainability.

O que é TDD ?

TDD é a sigla para Test-Driven Development. É uma prática de desenvolvimento de software que enfatiza a criação de testes automatizados antes da implementação real do código. O processo TDD segue um ciclo repetitivo de três passos:

Escrever um teste: Inicialmente, você escreve um teste automatizado que descreve o comportamento que você deseja implementar no código. Esse teste geralmente falha inicialmente, pois a funcionalidade ainda não está implementada.
Escreva o código que satisfaça o teste: Em seguida, você escreve o código de produção necessário para fazer o teste passar. O objetivo é fazer o código passar no teste e nada mais. Isso promove um desenvolvimento incremental e focado no requisito.
Refatorar o código: Após fazer o teste passar, você pode refatorar o código, melhorando sua estrutura e qualidade sem alterar seu comportamento externo. Os testes existentes ajudam a garantir que as alterações não quebram a funcionalidade existente.

O ciclo TDD é repetido várias vezes, com cada novo teste cobrindo um aspecto específico da funcionalidade que está sendo desenvolvida. Isso ajuda a garantir que o código seja testado de forma abrangente e que a funcionalidade atenda aos requisitos estabelecidos. TDD também promove a criação de um conjunto de testes automatizados robustos que podem ser executados regularmente para verificar a integridade do código.

O TDD é frequentemente associado a práticas ágeis de desenvolvimento de software e é considerado uma abordagem eficaz para melhorar a qualidade do código e a manutenibilidade do software.

How Java works ?

Marcos Mendes — Fri, 20 Oct 2023 22:57:50 +0000

Summary

🇺🇸 English
🇧🇷 Portuguese

How Java works ?

One of the main characteristics of Java is its ability to write once, run anywhere, therefore Java is a language with the concept of being cross-platform, this means that we can write code on a certain platform (MacOS for example), and we have the ability to use the same code on different platforms (Windows or Linux).

For example, we have a simple code written in Java and we use MacOS as the platform:

Let's suppose we need to run this same code in a Windows or Linux environment, what should we do?

By default, our machine (Windows, Mac or Linux) cannot understand code written in Java, after writing our source code, we need to convert this code to a format that our machine needs to understand, and at that moment we need a little guy called JavaC (Java Compiler).

Java Compiler (JavaC)

JavaC will receive our source code and compile it to ByteCode, after compilation we still cannot use it directly on our platforms.

After compiling our source code to ByteCode, another little guy comes into action, called JVM (Java Virtual Machine).

Java Virtual Machine (JVM)

The JVM (Java Virtual Machine) is a virtual machine that interprets and executes our ByteCode generated by JavaC at run time, and one of the main characteristics of the JVM is the Its ability to guarantee the portability of our ByteCode, allowing the same ByteCode that was generated on MacOS to be executed on a Windows JVM or a Linux JVM.

Compiled or Interpreted ?

So in the end, is Java a compiled or interpreted language? Java is a compiled and then interpreted language.

This occurs because our source code is first compiled by JavaC and generated the ByteCode, and then this same ByteCode will be interpreted by the JVM in a way that the platforms can execute.

1 - Source code compiled by JavaC and generated ByteCode.
2 - ByteCode is interpreted by the JVM and executed.

And now after understanding this entire concept above, how do we install the JVM on our machine?

Now we have two options, install the JRE or JDK.

JRE

The Java Runtime Environment (JRE) is the execution environment for Java.

The JRE will provide the JVM, but it will only be what we need to run our application.

What will I have inside the JRE?

JVM.
Libraries to be able to run our application.
Supports and resources needed to run our application.

JDK

The Java Development Kit (JDK), as the acronym itself says, is the development kit for Java.

The JDK is a set of tools and utilities necessary for us to be able to develop our application, and it will also provide everything that the JRE implements, that is, when we install the JDK we also install the JRE, and also we have other utilities such as:

JavaC (Java Compiler).
Debugger.
Utilities to assist us in our development.

With this we have an understanding of the concept of how Java is compiled and interpreted and its utilities.

Como funciona o Java ?

Uma das principais características do Java é a capacidade que ele tem de ser um Write once, Run anywhere (Escreva uma vez, execute em qualquer lugar), então o Java é uma linguagem com conceito para ser multi-plataforma, isso significa que nós podemos escrever um código em uma determinada plataforma (MacOS por exemplo), e nós temos a capacidade de usar o mesmo código em diversas plataformas (Windows ou Linux).

Por exemplo nós temos um código simples escrito em Java e utilizamos o MacOS como plataforma:

Vamos supor que nós precisamos rodar esse mesmo código em um ambiente Windows ou Linux, o que devemos fazer ?

Por padrão a nossa maquina (Windows, Mac ou Linux) não consegue entender um código escrito em Java, após escrever o nosso código fonte, nós precisamos converter esse código para um formato que nossa máquina precisa entender, e nesse momento precisamos de um carinha chamado JavaC (Java Compiler).

Java Compiler (JavaC)

O JavaC vai receber o nosso código fonte e vai compilar para ByteCode, após a compilação ainda não conseguimos utilizar ele diretamente nas nossas plataformas.

Após a compilação do nosso código fonte para ByteCode, um outro carinha entra em ação, chamado JVM (Java Virtual Machine).

Java Virtual Machine (JVM)

A JVM (Java Virtual Machine) é uma maquina virtual que interpreta e executa nosso ByteCode gerado pelo JavaC em tempo de execução, e uma das principais características da JVM é a capacidade que ela tem de garantir a portabilidade do nosso ByteCode, permitindo que o mesmo ByteCode que foi gerado no MacOS consiga ser executado em uma JVM do Windows ou uma JVM do Linux.

Compilada ou Interpretada ?

Então no fim das contas, o Java é uma linguagem compilada ou interpretada ? O Java é uma linguagem compilada e depois interpretada.

Isso ocorre, devido o nosso código fonte ser primeiro compilado pelo JavaC e gerado o ByteCode, e depois esse mesmo ByteCode vai ser interpretado pela JVM de uma forma que as plataformas consigam executar.

1 - Código fonte compilado pelo JavaC e gerado o ByteCode.
2 - ByteCode é interpretado pela JVM e executado.

E agora depois de entender todo esse conceito acima, como a gente faz para instalar a JVM na nossa máquina ?

Agora temos duas opções, instalar o JRE ou o JDK.

JRE

O Java Runtime Environment (JRE) é o ambiente de execução do Java.

O JRE fornecerá a JVM, mas será apenas o que precisamos para executar nossa aplicação.

O que eu vou ter dentro do JRE ?

JVM.
Bibliotecas para ser possível executar nossa aplicação.
Suportes e recursos necessários para executar nossa aplicação.

JDK

O Java Development Kit (JDK) como a própria sigla já diz, é o kit de desenvolvimento para Java.

A JDK é um conjunto de ferramentas e utilitários necessários para que a gente consiga fazer o desenvolvimento da nossa aplicação, e também vai fornecer tudo que a JRE implementa, ou seja, quando instalamos a JDK também instalamos a JRE, e também temos outros utilitários como:

JavaC (Java Compiler).
Debugger.
Utilitários para nos auxiliar no nosso desenvolvimento.

Com isso temos um entendimento do conceito de como o Java é compilado e é interpretado e seus utilitários.

Node.js - O que é, como funciona

Marcos Mendes — Tue, 08 Aug 2023 23:58:45 +0000

O que é o Node.js?

Diferente do que muitos pensam o Node.js não é uma linguagem de programação, e sim uma plataforma (runtime) que permite rodar código JavaScript (que no caso é uma linguagem de programação) no Servidor.

Bom, inicialmente o JavaScript foi criado para rodar apenas em Browsers, porém em 2008 foi lançada uma nova versão do Google Chrome e junto com essa nova versão veio o V8 que é um interpretador de código JavaScript.

E em 2009, um engenheiro de software chamado Ryan Dahl executou o V8 no Servidor, ou seja, fez com que o código JavaScript fosse interpretado no lado do Servidor em vez do lado do Cliente (Browsers), e com isso nasceu o que a gente conhecem hoje como Node.js.

Como o Node.js executa nosso código?

Vamos começar entendendo sobre Call Stack, Thread Pool, Event Loop e Callback Queue.

Call Stack

A call stack é a pilha de processamento do nosso código, ou seja, todas as funções que executarmos irão para essa pilha (stack).

Vamos a um exemplo prático da Call Stack e vamos analisar o código abaixo:

function multiply(x, y) {
  return x * y;
}

function printSquare(x) {
  const square = multiply(x, x);
  console.log(square);
}

printSquare(5);

Ao rodarmos o código acima, o JavaScript irá ler de cima para baixo, declarar as duas funções (multiply e printSquare) e ao final de tudo, irá invocar a função printSquare passando o valor 5 no argumento.

Veja a imagem abaixo para melhor compreensão.

Step 1.

Quando invocamos a função printSquare, é aqui que entra a nossa Call Stack em ação, como mencionei anteriormente, todas as funções que executamos no nosso código vão para a nossa call stack (pilha de processamento), então a função printSquare já está lá.

Step 2.

Dentro da função printSquare, a gente chama na primeira linha a função multiply, então a função multiply, também entra na pilha de chamadas.

Step 3.

Bem, dentro da função multiply não vamos mais a nenhum lugar, não chamamos nenhuma outra função ou algo do tipo, simplesmente pegamos os argumentos x e y multiplicamos um pelo outro e retornamos o resultado, então a partir do momento que a função multiply está retornando o resultado, o papel dela é concluído e ela sai da nossa pilha de chamadas.

E agora, voltando para dentro da função printSquare, chamamos um console.log() para mostrar o resultado, então a função console.log entra na nossa pilha de chamadas, é executada e depois sai da pilha.

Step 4 & 5:

E agora, como não temos mais nada para fazer dentro da função printSquare, o processamento do nosso código acabou e a função printSquare também sai da nossa call stack.

Bom, com isso já conseguimos notar uma característica da Call Stack: A primeira função que entra é a última que sai.

A call stack tem muito peso em nosso código e por isso é muito importante sabermos sobre sua existência e entender como ela funciona.

Single Thread

Outra característica do Node.js é que ele é Single Thread, ou seja, só pode executar uma tarefa por vez.

“Mas como assim ele só executa uma tarefa por vez, ouço todo mundo falando que o Node.js é Non-Blocking I/O, ou seja, tem entrada e saída de dados de forma não bloqueante”.

De fato, o Node.js não pode executar mais de uma tarefa por vez, temos apenas 1 call stack, e enquanto ela estiver ocupada, não podemos executar mais nada.

“Então, por que falam que o Node.js é Non-Blocking I/O e que pode executar mais de uma tarefa ao mesmo tempo?”

Porque de fato ele é Non-Blocking I/O e também de fato ele pode executar mais de uma tarefa ao mesmo tempo, e ele consegue fazer isto mesmo sendo Single Thread, porque por debaixo dos panos ele roda em uma biblioteca escrita em C chamada libuv.

A libuv implementa o Thread Pool e o Event Loop, também implementa toda a parte do filesystem do Node, DNS e etc. A libuv é uma biblioteca muito completa e dá muitos poderes ao Node.

Se quiser conhecer mais sobre a libuv, aqui estão alguns links uteis:
Site oficial
Github
Libuv no Node.js

Bem, vamos prosseguir, considere o seguinte código:

console.log('Before.');

db.query(query, function callback(error, data) {
  console.log(data);
});

console.log('After.')

Logo na primeira linha temos um console.log que já entra em nossa pilha de chamadas, é executado e sai dela.

Depois disso, vamos para a linha debaixo, onde temos a função db.query, e é aqui que começa a diversão.

Essa função db.query é o que chamamos de função bloqueante, o que significa que ela leva um certo tempo para ser executada, pois nesse caso ela precisa se conectar ao banco de dados, executar uma consulta, aguardar a resposta do banco de dados, e trazer as informações de volta, e tudo isso leva um certo tempo, e se o Node não tomasse nenhuma ação em cima disso, essa função db.query ficaria presa em nossa call stack, bloqueando a execução do código, ou seja, não poderíamos passar para a próxima linha até que a função db.query fosse resolvida, e é por essa razão que chamamos ela de função bloqueante, porque ela bloqueia nossa pilha de processamento.

Porém, o Node.js não deixa isso acontecer, pois ele entende que essa função db.query vai bloquear a call stack, então ele pega e joga essa função para dentro da Thread Pool e a remove da nossa call stack.

Enquanto nossa query está sendo executada dentro da Thread Pool, nosso código continua sendo executado, então ele vai normalmente para nosso console.log() da última linha, executa e o remove logo em seguida, e a execução do código principal termina.

Então lá na Thread Pool, a query está sendo executada e após terminar a execução da mesma, a função de callback do db.query é lançada na “Callback Queue”.

Após a função de callback da db.query estar dentro da callback queue, o Event Loop entra em ação, pense nele como um while(true) que fica sempre verificando se existe alguma função pronta para ser executada dentro da callback queue.

Se o Event loop encontrar alguma função que está pronta para ser executada e nossa pilha de chamadas não tiver mais funções pendentes para serem executadas, ele puxa essa função que está pronta para ser executada para a pilha de chamadas e continua processando o código normalmente.

Lembra que dentro da função de callback da query.db tínhamos um console.log ? Então, em seguida, ele será executado e após sua execução será removido da pilha. E agora, como nossa função de callback não tem mais nada para executar, ela também é retirada da pilha.

E é assim que o Node.js consegue executar código assíncrono.

Bom, isso é tudo que eu pretendia escrever para esse post, talvez em um próximo post, eu escreva mais do funcionamento do Node e etc.

Espero que tenha lhe ajudado de alguma forma, seu feedback (positivo ou negativo) é sempre bem-vindo :D

Five Things Every iOS Developers Must To Know

Marcos Mendes — Tue, 25 Jul 2023 12:27:48 +0000

Xcode

Xcode is the official integrated development environment (IDE) for iOS app development. It includes everything needed to design, develop, and test iOS apps, as well as publish them to the App Store. Xcode includes features like a code editor, debugging tools, Interface Builder, and simulators.

Swift

Swift is Apple’s programming language used for developing iOS apps. It is a fast and efficient language designed to work with Apple’s frameworks and APIs.

CocoaPods

CocoaPods is a dependency manager for iOS app development. It helps manage third-party libraries and frameworks, making it easy to integrate them into an iOS project. CocoaPods simplifies the process of adding and updating dependencies, and it includes tools for resolving version conflicts.

GitHub

GitHub is a web-based platform for version control and collaboration. It is a great tool for iOS developers who want to manage their code and work with other developers on a project. GitHub provides features like pull requests, issue tracking, and code reviews.

Firebase

Firebase is a mobile and web application development platform that provides a suite of tools and services for iOS app development. It includes features like authentication, real-time database, cloud storage, and analytics. Firebase helps iOS developers build high-quality apps quickly and easily.

Swift - Data Types Explained

Marcos Mendes — Tue, 28 Feb 2023 13:27:24 +0000

Hello everyone, today I want talk a little bit about Data Types in Swift.

Data Types are the most important part of any programming language. Swift support six data types: Int, String, Float, Double, Bool and Character.

So let's start.

1. Int: In Swift, the integer is a data type that is used to represent a whole number with no fraction, for example, “2”, “56”, “3”, etc. Integer can be of 8, 16, 32, and 64 signed or unsigned bits. A variable of integer data type can be defined using the Int keyword. Int can be represented as a signed integer and UInt represents an unsigned integer.

Ex: var age: Int = 22

2. String: In Swift, the string is used to represent a sequence of characters or textual data, for example, “GeeksforGeeks”. The variable of string data type is defined using the String keyword.

Ex: var firstName: String = "Marcos"

3. Float: In Swift, the float data type is used to represent decimal numbers or we can say that float is used to represent 32-bit floating-point numbers, for example, “3.23”, “0.89753”, etc. It stores data with less precision. This data type represents up to 6 decimal places, so it is generally used when the floating-point number is less. If you want to store more decimal places then you can use a double data type. The variable of float data type is defined using the Float keyword.

Ex: var inputData: Float = 3.43

4. Double: Double data type is used to represent a number with fractional components or we can say that double data type is a 64-bit floating-point number, for example, “2.3345656”, “0.24354656”, etc. This data type represents up to 15 decimal places and it is generally used when the floating-point number is large. The variable of double data type is defined using the Double keyword.

Ex: var inputData: Double = 23.45788

5. Bool: In Swift, bool or boolean is used to represent logical entities. This data type has only two values that is true or false. Here the variable of boolean data type can be defined using the Bool keyword.

Ex: var isLoading: Bool = true

6. Character: In Swift, the character is used to represent a single letter or string literal. For example “G”, “E”, “K”, “S”, etc. A variable of character data type can be defined using the Character keyword.

Ex: var myInitial: Character = "M"

How to learn Swift in 2023 ?

Marcos Mendes — Sat, 25 Feb 2023 18:58:11 +0000

Introduction

Hi folks, I currently learning iOS Development and the Swift Programming Language, and I like to share with yous more about Swift and how I'm studying and practicing.

So if you are interested to learning Swift, come with me 👨🏻‍💻

What's Swift ?

Swift is an open source programming language created by Apple in June/2014.

Is a consistent and intuitive language for make apps to Apple Ecossystem (iPhone, Mac & Macbook, Apple TV, Apple Watch)

Swift combines powerful type inference and pattern matching with a modern, lightweight syntax, allowing complex ideas to be expressed in a clear and concise manner. As a result, code is not just easier to write, but easier to read and maintain as well.

Hello World in Swift:

Great places to Learning Swift

I'm listing some places that I use to learn Swift, which might be useful for you too.

Why learn Swift ?

Swift is a fast and efficient language, we can write safer and more reliable codes with type inference, we save time, and it is a modern and interactive language.

It's really cool to create Apps, it's amazing to see applications that we create being used by people and making a difference in their lives.

Conclusion

Swift is cool.
If you learn this language, I believe you won't regret it, both for your evolution as a professional and the job opportunities that may arise for you.

My links

7 Soft Skills Every Software Engineer Should Have in 2023⚡🧑‍💻

Marcos Mendes — Mon, 23 Jan 2023 18:15:12 +0000

What are Soft Skills?

First, hard skills are basically skills that can be measured or quantified in some way. They are job-specific and can be learned in institutions or through apprenticeship courses.

Soft skills are less defined and more universal, as they cut across all careers that exist today.

1 - Effective and assertive communication

You must communicate clearly, which means you must always put yourself in your listener's shoes, whether they are a user, a product manager or a teammate.

Show genuine appreciation for people and their work, people can always feel it when you do. These tips lead to a better work environment where everyone feels seen, heard and valued.

2 - Self-awareness

This is a very important skill to hone. It involves understanding yourself at all times. Working as a developer, it's important in your day to day life to be very confident to express what you know, and very capable of expressing or communicating what you don't yet know.

It's a sign of strength to respond with, "I still have no idea how this works." Show honesty and willingness to learn.

3 - Time management

Time management skills are super important in every developer's life, as almost every project you'll be working on has a deadline.

One tip is to create a schedule for yourself and stick to it. Also, creating healthy breaks and having boundaries can be very helpful. You have to make time to eat, exercise, rest and work.

4 - Empathy

This simply means putting yourself in other people's shoes, this would mostly involve your daily interactions at work. Do you remember to make sure the codebase is as readable as possible for the next person accessing it?

Practice being understanding when teammates underperform, try to find out if they are dealing with anything in their personal lives

5 - Responsibility

Taking ownership of your decisions, choices and actions at every point of your journey is also another very important skill to have. Realizing that everyone makes mistakes and failure isn't necessarily a bad thing will help a lot.

Some of the mistakes you'll make as a developer can be less impactful for the company or team, while others can have a huge negative impact.

Bonus -> Open Mind

Developers, by nature, are often strongly opinionated, and this applies to everything in your everyday life. Having an open mind can be a great skill to have.

You can be very stubborn, but you are still open to new things, new ideas and a new framework to achieve your goals better and more effectively.

⚡ Introduction to Next.js

Marcos Mendes — Fri, 20 Jan 2023 12:44:01 +0000

What is Next.js ?

Next.js is a flexible web framework built on React.js that provides a lot of functionality to create high-performance applications.

More about Next.js

Next.js offers a better developer experience, with several features you need to take your project to production:

Hybrid rendering (static and server)
TypeScript support
CSS-in-JS (Styled components, Styled-JSX)
Zero Configuration (Routes, Hot Reloading)
Optimization of Images and Fonts
Optimized for Production

Some Companies that use Next.js

Tiktok
Github
Twitch
Nike
Uber

You can see more companies that use next at this link: https://nextjs.org/showcase

Get started

You can use React to build your user interface and gradually adopt Next.js features to solve common application requirements like routing, data fetching and integrations.

You can use create-next-app to create a project in Next, it automatically configures everything for you.

npx create-next-app@latest --typescript
yarn create next-app --typescript

Useful links

If you want to know more about Next.js
Below are some useful links for you.

Official website (https://nextjs.org/)
Documentation (https://nextjs.org/docs/getting-started)
What's New in Next.js 13 (https://nextjs.org/blog/next-13)

⚛️⚡️ Introduction to React Hooks

Marcos Mendes — Wed, 18 Jan 2023 12:08:12 +0000

What are Hooks?

Let's start by understanding what Hooks are, Hooks are an innovation, a modification that the React team has made available to us since version 16.8

Hooks are basically a way to create components and create your application's features without creating entire classes with a lifecycle, constructors, defining various states, binding functions, and so on. Now with a simple variable we can create a complete and complex component with the use of Hooks, Hooks have come to change the way we code our features in order to use even less code and with more performance.

So, if we compare a component created using Hooks with a component created with classes, the one created with Hooks is infinitely smaller in terms of the amount of code, and this is very beneficial both for production time and for your productivity.

Anyway, Hooks are functions (which always start with the word use) that allow you to “connect” to React's state and lifecycle resources from functional components, and just to point out Hooks don't work inside classes.

Three important features about Hooks:

They only work on functional components.
They must always be invoked in the main scope of your component (for example outside ifs and functions).
And finally, they cannot be linked to any conditional to be executed.

React provides some built-in Hooks like useState (we'll see in the next post), but you can also create your own custom Hooks to reuse state behavior between different components.

Hope this article helped you to understand more about React Hooks