DEV Community: João Costa

CAP Theorem and Business Trade-Offs

João Costa — Tue, 18 Mar 2025 13:45:07 +0000

In the world of distributed systems, the CAP theorem is a fundamental principle that guides how we design and manage data consistency, availability, and fault tolerance. Originally formulated by Eric Brewer in 2000 and later formally proven, the theorem states that a distributed system can only achieve two out of the following three guarantees:

Consistency (C): Every read request receives the most recent write or an error.
Availability (A): Every request receives a response, though it may not contain the latest data.
Partition Tolerance (P): The system continues to function despite network failures that divide nodes.

Since network failures are inevitable, distributed systems must always support partition tolerance (P). This leaves system architects with a critical trade-off between Consistency (C) and Availability (A).

Choosing Between Consistency and Availability

CP (Consistency & Partition Tolerance) Systems

A CP system prioritizes consistency over availability. If a network partition occurs, the system will reject some requests (returning errors or timeouts) rather than provide stale data.

CP is a good choice if your business needs require atomic reads and writes.

Business Models That Prioritize Consistency:

Banking and Financial Transactions: When making a bank transfer, it is crucial that the balance updates immediately across all nodes. Inconsistent data could lead to double spending or incorrect account balances.
E-Commerce Payment Processing: An online store must ensure that an item is available before confirming an order to avoid overselling.
Healthcare Systems: A patient’s medical records must always reflect the latest data to avoid incorrect diagnoses or prescriptions.

AP (Availability & Partition Tolerance) Systems

An AP system prioritizes availability over consistency. It ensures that every request gets a response, even if the data is not the most up-to-date version.

AP is a good choice if the business needs to allow for eventual consistency or when the system needs to continue working despite external errors.

Business Models That Prioritize Availability:

Social Media Platforms: When posting a comment on social media, slight delays in synchronization are acceptable. Users expect instant feedback even if the latest interactions take time to propagate.
Streaming Services: When streaming a video, the system should continue to serve content even if certain servers are temporarily unavailable.
E-Commerce Shopping Carts: An online shopping cart must function even if a network issue occurs. The cart can synchronize later when connectivity is restored.

Making the Right Trade-Off

Choosing between CP and AP depends on business needs:

Choose CP when data integrity is critical and errors cannot be tolerated.
Choose AP when availability is crucial, and eventual consistency is acceptable.

Understanding the CAP theorem helps businesses make informed decisions about their distributed system architecture. Whether optimizing for financial accuracy, customer experience, or operational resilience, choosing the right balance between consistency and availability is key to building reliable, scalable applications.

Steve Wendel's CREATE Action Funnel

João Costa — Tue, 11 Mar 2025 15:00:33 +0000

One of the most powerful tools in product design is behavioral science. It helps us understand how people make decisions and take action—or why they don’t. A great framework for applying behavioral science to software products is Steve Wendel’s CREATE Action Funnel, which breaks down user behavior into six key steps: Cue, Reaction, Evaluation, Ability Check, Time Pressure, and Experience.

If you want to design products that drive action, learning how to apply this funnel can help. Let’s explore how it works with fresh examples in 2025.

The CREATE Action Funnel

Here’s a breakdown of the framework and how it applies to real-world digital products today:

Cue – What triggers the user to consider taking action?
Reaction – What is their instinctive first response to the trigger?
Evaluation – What rational cost-benefit analysis do they conduct?
Ability Check – Can they actually complete the action at this moment?
Time Pressure – Do they feel a sense of urgency?
Experience – What is their emotional takeaway after completing (or failing to complete) the action?

Now let’s look at two product experiences—one where the funnel led to success and another where it broke down.

Successful Example: Duolingo’s Daily Streak

Cue:

I receive a push notification from Duolingo: "You're so close to a 30-day streak! Don't stop now!"

Reaction:

"Oh wow, I don’t want to break my streak!"

Evaluation:

"It’s just one quick lesson, and I’ve already invested so much time. Plus, I’m actually improving my Spanish."

Ability Check:

"I have my phone with me, and I can spare five minutes."

Time Pressure:

"I need to do it before midnight or I’ll lose my streak."

Experience:

"Nice! I kept my streak, and that felt rewarding. I’ll do it again tomorrow."

What Happened?
Duolingo masterfully drives daily engagement by combining streak-based motivation, push notifications, and an effortless way to complete the action. The CREATE framework explains why it works: They nail the cue (push notifications), drive an emotional reaction (loss aversion), make it easy to evaluate the benefits, and add just the right amount of time pressure.

Unsuccessful Example: Threads App Re-Engagement

Cue:

I receive an email from Threads: "Come see what your friends are talking about!"

Reaction:

"Hmm, do I really care what’s happening on Threads?"

Evaluation:

"I haven’t really found it that engaging, and my friends still seem more active on Twitter."

Ability Check:

"I can open the app, but is it worth my time?"

Time Pressure:

"No urgency here—I can check anytime."

Experience:

"Opened the app, saw a few random posts, closed it again. Not convinced to keep coming back."

What Happened?
Threads’ attempt to re-engage users fails at the Evaluation step. The content isn’t compelling enough to justify the time spent, and there’s no strong urgency or reward for engaging. A stronger hook—like personalized trending content or limited-time discussions—could improve the experience.

Key Takeaways for Product Designers

Make the cue compelling. Your trigger should be hard to ignore (but not annoying). Personalized push notifications, habit loops, and external reminders can help.
Understand the gut reaction. Users often make decisions emotionally before rationalizing them.
Minimize friction in the evaluation phase. Make benefits obvious and reduce effort.
Ensure ability aligns with intent. If users can’t take action immediately, they might never come back.
Create urgency when it makes sense. But don’t force it—fake urgency can backfire.
Design for long-term experience. The better the initial experience, the more likely users will come back.

Closing Thoughts

Behavioral science is a game-changer in product design, and the CREATE funnel is a practical tool for analyzing and optimizing user behavior. If you’re a product manager, designer, or growth marketer, try mapping out your own product’s user journeys with CREATE. Share your findings, experiment with tweaks, and keep learning in public—because the best products are built through curiosity, iteration, and community insights.

What’s a product you’ve seen succeed (or fail) through behavioral design? Drop a comment and let’s discuss!

Fogg Behavior Model & 2025 Tech Applications

João Costa — Thu, 20 Feb 2025 13:39:51 +0000

A Brief Dive into the Fogg Behavior Model

I recently spent some time reading BJ Fogg’s work on behavior design, specifically his Fogg Behavior Model (FBM). It’s a simple yet powerful framework that explains how human behavior is driven by three key factors: Motivation, Ability, and Triggers. If all three align at the same moment, the behavior happens. If one is missing, it doesn’t.
While Fogg’s model has been around for a while, what struck me is how relevant it is today—especially in a world increasingly shaped by AI, social media, and automation. I wanted to share some insights on how FBM plays out in 2025’s tech landscape and what we can learn from it.

Breaking Down the Model

1. Motivation: Do Users Care Enough?

Motivation is what drives people to act. Fogg categorizes motivation into three dimensions:

Pleasure vs. Pain
Hope vs. Fear
Social Acceptance vs. Rejection

2. Ability: Is It Easy Enough?

If something is too hard, people won’t do it—even if they’re motivated. Ability comes down to simplicity. The easier an action is, the more likely people are to follow through. Factors like time, money, effort, and mental energy all play a role here.

Fogg defines six elements of simplicity that determine whether a behavior feels easy to do:

Time – If an action takes too long, people are less likely to do it.
Money – If it’s costly, it creates friction for users.
Physical Effort – Actions that require significant exertion are avoided.
Cognitive Effort (Brain Cycles) – Complex thinking and decision-making reduce the likelihood of action.
Social Deviance – If a behavior goes against social norms, people may resist it.
Non-Routine – If something is unfamiliar or doesn’t fit into a habit, it may feel difficult.

For designers and product creators, reducing barriers in these areas significantly increases the likelihood of users performing a behavior.

3. Triggers: What’s the Nudge?

Even when motivation and ability are high, a behavior still needs a trigger. Triggers can be:

Sparks (motivational nudges, like urgent notifications)
Facilitators (making the action easier, like auto-fill in forms)
Signals (reminders, like a daily step goal notification)

2025 Tech Examples of FBM in Action

1. AI-Powered Health Apps (Motivation + Ability + Triggers)

Apps like Apple Health and Google Fit have evolved beyond tracking steps. They now use real-time AI coaching to motivate users (Hope vs. Fear: “Stay healthy to avoid chronic diseases”), simplify workouts (quick, adaptive exercises), and trigger action (smart reminders based on habits).

2. Autonomous Vehicles & Ridesharing (Reducing Ability Barriers)

Self-driving taxis are here, and they’ve removed a huge ability barrier—driving itself! Even people with low motivation to drive can now summon a car effortlessly through voice commands or wearables.

3. AI-Generated Content & Productivity Tools

GPT-powered assistants and tools like Notion AI are removing friction in writing, brainstorming, and summarizing information. The trigger? A simple notification that asks, “Want to turn this outline into a full draft?”—right when you’re thinking about it.

4. Social Media & Short-Form Content (Strong Triggers)

Platforms like TikTok and Instagram Reels perfectly execute FBM. They:

Trigger users with push notifications (“Your friend just posted!”)
Lower ability barriers (just scroll to consume content, no effort required)
Leverage motivation (social acceptance: fear of missing out, pleasure of entertainment)

5. Smart Homes & Voice Assistants (Effortless Triggers)

Alexa and Google Home have reached a point where they can predict user needs and trigger actions autonomously (e.g., lowering lights when bedtime approaches). No effort, no manual activation—just behavior happening naturally.

Key Takeaways

Simplification Wins – The easier something is, the more likely people are to do it. Reducing friction beats increasing motivation.
Triggers Must Be Well-Timed – Even if motivation and ability are there, behavior won’t happen without the right nudge.
AI & Automation Are Mastering FBM – Many 2025 technologies predict when users are ready to take action and nudge them at the perfect moment.

Final Thoughts

Fogg’s model provides an insanely useful lens to analyze why people do or don’t take action. If you’re designing anything—an app, a habit system, or even your daily routine—keeping these three factors in mind can dramatically increase success.

Would love to hear your thoughts: Where do you see FBM at play in today’s tech? Drop a comment!

Server-Side Caching vs. Client-Side Caching

João Costa — Wed, 12 Feb 2025 13:44:29 +0000

Introduction

Ever wondered why websites load faster after your first visit? That’s caching at work! Caching helps improve webpage speed and reduces the load on servers. Tech giants like Facebook, Google, Instagram, and YouTube leverage caching to deliver seamless user experiences.

🏗 Understanding Caching

Caching refers to the process of storing frequently requested data in temporary storage for quick retrieval. It minimizes redundant data processing and reduces server requests, significantly enhancing performance.

What Is Website Caching?

Website caching involves storing webpage data either on the server or on the user’s device. It is broadly classified into:

Server-side caching
Client-side caching
Remote caching

🚀 Server-Side Caching

Server-side caching involves storing web data on the server to accelerate future requests.

How It Works

A user requests a webpage for the first time.

The server retrieves data from the database and builds the page.

The response is delivered to the user while a copy is saved in the cache.

On subsequent visits, the server serves the cached version, reducing processing time and improving speed.

Types of Server-Side Caching

Object Caching - Stores database query results for faster retrieval.

CDN Caching - Uses distributed servers to cache and deliver content globally.

Challenges of Server-Side Caching

Stale Data: Cached content might become outdated if not refreshed properly.

Latency Issues: Inefficient caching strategies can introduce delays instead of improving speed.

⚡ Client-Side Caching

Client-side caching stores data directly on the user’s device, minimizing the need for repeated server requests.

How It Works

The user visits a webpage, and the browser saves static assets like images and scripts.

On the next visit, the browser loads cached assets instead of fetching them again from the server.

Types of Client-Side Caching

Browser Caching - Uses HTTP headers (Cache-Control, ETags) to manage cache policies.

JavaScript/AJAX Caching - Retains fetched data to avoid unnecessary API calls.

HTML5 Caching - Stores assets using LocalStorage, SessionStorage, or IndexedDB.

Challenges of Client-Side Caching

Cache Invalidation: Users may see outdated content unless properly managed.

Browser-Specific: Cached content is stored per browser, meaning switching browsers requires new downloads.

Feature	Server-Side Caching	Client-Side Caching
Reduces database load	✅ Yes	❌ No
Works across all clients	✅ Yes	❌ No
Optimizes static assets	❌ No	✅ Yes
Best for API responses	✅ Yes	❌ No
Requires extra storage	✅ Yes (Redis, etc.)	❌ No

🔥 Conclusion

Both server-side caching and client-side caching play crucial roles in optimizing performance. A hybrid approach often works best for real-world applications.

👉 Use server-side caching to reduce redundant database queries and API requests.
👉 Use client-side caching to minimize network latency and enhance page load speed.

Start implementing caching today to build faster, more efficient applications! 🚀

Did you find this guide helpful? Let’s chat in the comments or connect on Linkedin/Github.

Testing a GraphQL Application with Jest and SuperTest

João Costa — Mon, 13 Jan 2025 18:19:30 +0000

In this blog post, we'll explore the challenges and solutions involved in testing a GraphQL API using Jest and SuperTest. The journey began with the need to simulate headers, specifically for token-based authentication, in Jest tests.

The Challenge: Simulating Headers in Jest

While developing the Todo Backend GraphQL project for the Woovi challenge, I encountered a significant roadblock. I needed to test the GraphQL API's authentication, which relies on JSON Web Tokens (JWT) passed in the HTTP headers. Initially, I struggled to find a straightforward way to simulate these headers in Jest. The standard Jest setup wasn't enough because it didn't directly handle HTTP requests and responses in the same way a real server does.

The Solution: Discovering SuperTest

After several trials and errors, I came across SuperTest, a library designed for HTTP assertions. SuperTest extends the functionality of Jest by allowing you to test HTTP servers as if they were real clients. This capability made it possible to simulate headers, including the authorization tokens required for my API's authentication.

Setting Up the Test Environment

Before diving into the tests, let's set up the environment.

Install Dependencies First, ensure you have Jest, SuperTest, and Faker installed:

   npm install --save-dev jest supertest faker

Configure Jest Create a jest.config.js file:

   module.exports = {
     preset: 'ts-jest',
     testEnvironment: 'node',
   };

Write Test Cases With the environment ready, we can now write test cases.

Writing Tests with SuperTest

SuperTest became the game-changer in this scenario. Here's how I used it to test the API's CRUD operations and authentication.

Testing CRUD Operations with SuperTest

Setup and Teardown Use Jest's beforeAll and afterAll hooks for setup and teardown:

   import { connect, disconnectDatabase } from './mongooseConnection';
   import supertest from 'supertest';
   import app from './../index';

   beforeAll(async () => {
     await connect();
   });

   afterAll(async () => {
     await disconnectDatabase();
   });

Test Authentication and Token Usage Create a helper function to register a user and get the token:

   import { faker } from '@faker-js/faker';
   import { graphql } from 'graphql';
   import { schema } from '../schema';

   async function authUserTest() {
     const userTest = {
       name: faker.name.firstName(),
       email: faker.internet.email(),
       password: faker.internet.password(),
     };
     const source = `
       mutation {
         register(name: "${userTest.name}", email: "${userTest.email}", password: "${userTest.password}") {
           token
           user {
             name
             email
           }
         }
       }
     `;
     const result = await graphql({ schema, source });
     const data = result.data?.register;
     return data.token;
   }

Testing Tasks CRUD Operations

Create a New Task

 it('should create a new task', async () => {
   const todo = {
     task: faker.lorem.words(),
     status: faker.helpers.arrayElement(['pending', 'complete', 'in progress']),
   };
   const query = `
     mutation {
       todo(task: "${todo.task}", status: "${todo.status}") {
         task
         status
       }
     }
   `;
   const { body } = await supertest(app)
     .post('/graphql')
     .send({ query })
     .set('Accept', 'application/json')
     .set('Authorization', `Bearer ${await authUserTest()}`);
   expect(body.data.todo).toMatchObject(todo);
 });

Retrieve All Tasks

 it('should retrieve all tasks', async () => {
   const query = `
     query {
       todos {
         _id
         task
         status
       }
     }
   `;
   const { body } = await supertest(app)
     .post('/graphql')
     .send({ query })
     .set('Accept', 'application/json')
     .set('Authorization', `Bearer ${await authUserTest()}`);
   expect(body.data.todos).toBeInstanceOf(Array);
 });

Update a Task

 it('should update a task', async () => {
   const todos = await Todo.find();
   const randomTodo = todos[Math.floor(Math.random() * todos.length)];
   const updatedTask = faker.lorem.words();
   const updatedStatus = faker.helpers.arrayElement(['pending', 'complete', 'in progress']);
   const query = `
     mutation {
       updateTodo(_id: "${randomTodo._id}", task: "${updatedTask}", status: "${updatedStatus}") {
         task
         status
       }
     }
   `;
   const { body } = await supertest(app)
     .post('/graphql')
     .send({ query })
     .set('Accept', 'application/json')
     .set('Authorization', `Bearer ${await authUserTest()}`);
   expect(body.data.updateTodo.task).toBe(updatedTask);
   expect(body.data.updateTodo.status).toBe(updatedStatus);
 });

Delete a Task

 it('should delete a task', async () => {
   const todos = await Todo.find();
   const randomTodo = todos[Math.floor(Math.random() * todos.length)];
   const query = `
     mutation {
       deleteTodo(_id: "${randomTodo._id}") {
         _id
       }
     }
   `;
   const { body } = await supertest(app)
     .post('/graphql')
     .send({ query })
     .set('Accept', 'application/json')
     .set('Authorization', `Bearer ${await authUserTest()}`);
   expect(body.data.deleteTodo._id).toBe(randomTodo._id);
 });

Running the Tests

Run your tests using Jest:

npm test

This command will execute all test files, providing a detailed report of the results.

Conclusion

The difficulty in simulating headers in Jest led to the discovery of SuperTest, which significantly simplified the process. By leveraging SuperTest alongside Jest, I was able to effectively test the GraphQL API's authentication and CRUD operations, ensuring the application's security and functionality. Sharing this learning process highlights the power of public learning and community-driven problem-solving.

Mastering CSS Flexbox: A Guide with Handy Tips

João Costa — Mon, 13 Jan 2025 17:59:30 +0000

Flexbox, short for Flexible Box Layout, is a CSS3 web layout model that allows you to create more flexible and efficient layouts. If you're looking to improve your web design skills, mastering Flexbox is essential. Here's a comprehensive guide to understanding and using Flexbox effectively, complete with handy tips to elevate your web development game.

Understanding Flexbox

Flexbox is designed to provide a consistent layout on different screen sizes and devices. Unlike traditional layout techniques (such as floats or inline-block), which can be cumbersome and require additional CSS for alignment and spacing, Flexbox simplifies the process of aligning and distributing space among items in a container, even when their size is dynamic or unknown.

Key Flexbox Properties

For the Container (Parent Element):

display: Set to flex or inline-flex to create a flex container.
flex-direction: Defines the direction of the main axis (row, row-reverse, column, column-reverse).
justify-content: Aligns items along the main axis (flex-start, flex-end, center, space-between, space-around, space-evenly).
align-items: Aligns items along the cross axis (flex-start, flex-end, center, baseline, stretch).
align-content: Aligns a flex container's lines when there is extra space in the cross axis (flex-start, flex-end, center, space-between, space-around, stretch).

For the Items (Children Elements):

flex: Shorthand for flex-grow, flex-shrink, and flex-basis.
order: Specifies the order of the flex items.
align-self: Aligns an individual item on the cross axis, overriding align-items.

Handy Tips for Using Flexbox

Use Flexbox for Responsive Design: Flexbox is perfect for creating responsive layouts. By adjusting flex-direction, justify-content, and align-items, you can make your layout adapt to different screen sizes seamlessly.
Centering Made Easy: One of the most popular uses of Flexbox is centering items both horizontally and vertically. Use justify-content: center; and align-items: center; on the container to achieve this effortlessly.
Control Item Order: With the order property, you can rearrange items without changing the HTML structure. This is particularly useful for accessibility and responsive design.
Equal Spacing: To distribute items with equal spacing, use justify-content: space-between; or justify-content: space-around;. For equal margins on both sides, space-evenly works best.
Flex-Grow and Flex-Shrink: Understand how flex-grow and flex-shrink work to control the growth and shrinking behavior of items. This is crucial for creating flexible designs that adapt to varying content sizes.
Fallbacks: Always provide fallback styles for browsers that do not support Flexbox, ensuring a basic layout is still functional.
Combine with Media Queries: Enhance Flexbox layouts with media queries to create truly responsive designs that adapt to different devices and orientations.
Debugging: Use browser developer tools to inspect Flexbox elements. Most modern browsers have Flexbox debugging features that can help you visualize the layout and understand how each property affects the container and items.

Practical Examples

Basic Flexbox Layout

.container {
  display: flex;
  flex-direction: row;
  justify-content: space-between;
  align-items: center;
}

Centering an Item

.container {
  display: flex;
  justify-content: center;
  align-items: center;
  height: 100vh;
}

Conclusion

Mastering Flexbox can significantly enhance your web development skills, allowing you to create flexible, efficient, and responsive layouts with ease. Summarizing its key benefits, Flexbox provides simplified alignment, efficient space distribution, and adaptability to different screen sizes. To deepen your knowledge, explore additional resources and practice creating various layouts to fully harness the potential of Flexbox. By understanding the key properties and practicing with real-world examples, you’ll be well on your way to becoming a Flexbox pro. Keep experimenting and refining your layouts to fully leverage the power of Flexbox in your projects.

Creating Own Types In Typescript

João Costa — Sat, 08 Oct 2022 21:40:30 +0000

Enum

An enumeration is a type that represents named constants and is often refered to as an enum. It can be very good if meaning of constant value is'nt apparent, this can make the code easier to understand.

enum Response{
     Ok = 200,
     Error = 400
}

if (status === 200) {
  // do something
}

if (status === Response.Ok) {
  // do something
}

The problem with this approach is reflected exactly in numerical enums that are weakly-typed, although string enum are strongly-typed.

enum Level {
  High,
  Medium,
  Low
}
level = 5; // no error accur


enum Level {
  High = "H",
  Medium = "M",
  Low = "L"
}
level = "VH"; // a type error occur

Object Types

In first typescript has a good inferred types system for objects. When hovering the mouse over object you will see the type inferred to object and if you try to change a property to a value of a different type or try to add a property that there are'nt it will return an error.

const JackScore = {
  name: "Jack",
  score: 70
};

JackScore.score = 75; // no error accur
JackScore.score = 'test'; // a type error occur
JackScore.passed = true; // a type error occur

There is also an explicit way to type objects and it has the same strength.

const JackScore: { name: string; score: number; }  = {
  name: "Jack",
  score: 70
};

JackScore.score = 75; // no error accur
JackScore.score = 'test'; // a type error occur
JackScore.passed = true; // a type error occur

The both ways are strongly-typed, although if you wish reuse an object type could be tiring redefinning it each time and that's why type aliases and interfaces is so important.

Type Aliases and Interfaces

Type aliases and interfaces are ways of reuse your types and make typing process faster.

//without types alias and interfaces
const tomScore: { name: string; score: number } = {
  name: "Tom",
  score: 70,
};
const bobScore: { name: string; score: number } = {
  name: "Bob",
  score: 80,
};
const janeScore: { name: string; score: number } = {
  name: "Jane",
  score: 90,
};
//with types alias and interfaces
type Score = {            interface Score {
name:string,       or     name:string,
score:number              score:number
}                        }

const tomScore: Score = { name: "Tom", score: 70 };
const bobScore: Score = { name: "Bob", score: 80 };
const janeScore: Score = { name: "Jane", score: 90 };

What's difference between interface and type alias

Representing primitive types

Type aliases can represent primitive types, but interfaces can't.

type Name = string;

Representing arrays

Both reprensent arrays, although type alias approach is a lot more concise and clearer.

type Names = string[];

interface Names {
  [index: number]: string;
}

Representing tuples

Type aliases can represent tuples types, interfaces can't

type Point = [number, number];
}

Representing functions

Both can represent functions, but type alias is a lot more concise and clearer.

type Log = (message: string) => void;

interface Log {
  (message: string): void;
}

Creating union types

Only type aliases can represent union types.

type Status = "pending" | "working" | "complete";

Representing objects

both can represent types of an object and even the type alias being the most concise approach the equals operator (=) can result in the statement being confused for a variable assignment to an object literal.
We can say that there is a tie here.

type Person = {
  name: string;
  score: number;
};

interface Person {
  name: string;
  score: number;
}

Composing objects

Type aliases and interfaces can both compose objects together.

type Name = {
  firstName: string;
  lastName: string;
};
type PhoneNumber = {
  landline: string;
  mobile: string;
};
type Contact = Name & PhoneNumber;

interface Name {
  firstName: string;
  lastName: string;
}
interface PhoneNumber {
  landline: string;
  mobile: string;
}
interface Contact extends Name, PhoneNumber {}

Authoring a library

One important feature that interfaces have that type aliases don't is declaration merging:

interface ButtonProps {
  text: string;
  onClick: () => void;
}
interface ButtonProps {
  id: string;
}

This is is useful for adding missing type information on 3rd party libraries. If you are authoring a library and want to allow this capability, then interfaces are the only way to go.

Fundamentos de Redes de Computadores : Parte I

João Costa — Sat, 08 Oct 2022 15:32:58 +0000

Introdução a Redes de Computadores e Histórico da Internet

História da Internet

A internet surge no contexto da guerra fria em que havia duas potências em disputa tecnológica e objetivo era comunicar computadores que tinham acesso muito restrito e tornar mais flexível o compartilhamento de informações. Com isso surgem as primeiras redes com a Arpanet, uma rede que ligava os computadores dos EUA, e seus protocolos, um conjunto de regras que organizam a troca de informação, o TCP/IP.

Comutação De Circuitos X Comutação De Pacotes

Antes da internet, as redes de telefonia utilizam a comutação de circuitos e a mudança de paradigma para comutação de pacotes foi fundamental para conectividade e rápida expansão das redes de computadores em escala global.
Na comutação de circuitos é necessário um estabelecimento de uma rede física de circuitos entre a origem e destino antes da transmissão propriamente dita, enquanto na comutação de pacotes a informação é dividida em pacotes e são encaminhados de forma individual e independente.

Redes Definidas Por Software

Com o crescimento da rede de computadores as tarefas de gerência ficaram mais complicadas.As Redes Definidas Por Software (SDN) permitem programar o comportamento da rede de forma centralizada e controlada.Sua figura central é o controlador de redes, por onde o gerente políticas e comportamentos para toda a rede.

Internet Das Coisas (IoT)

O objetivo dessa iniciativa é comunicar não só computadores e celulares, mas também qualquer outro dispositivo do cotidiano (ex. geladeira, porta de casa, lata de lixo, par de sapatos) pudessem trocar dados e serem utilizados remotamente.

Nós, Enlaces e Protocolos

São os 3 componentes fundamentais da rede de computadores:
Nós => Representam os sistemas finais ou intermediários que são interconectados em rede.
Enlaces =>Representam as ligações físicas entre nós da rede, como fibra óptica e cabo coaxial.
Protocolos=>Implementam regras de comunicação nas redes que organizam e controlam o fluxo de informação.

Classificação De Rede Quanto a Topologia

A topologia influencia diretamente o desempenho e a robustez de uma rede.
Na topologia centralizada todos os nós se ligam ao nó central e dependem dele se houver falha toda rede será comprometida.
Na topologia descentralizada o papel do Nó central é reduzido, pois os nós estão ligados em sub regiões de concentração, porém se um elo falha pode comprometer partes da rede.
Na topologia distribuída os nós apresentam quase a mesma importância e a falha de um deles tem consequências mínimas para rede.

Classificação De Rede Quanto a Área de Cobertura (Alcance)

LAN, WLAN => São uma rede local que interliga computadores próximos.
MAN, WMAN => São redes metropolitanas que abrangem dezenas de km.
WAN, WWAN => São redes de longa distâncias que conseguem abranger país ou continente.
SAN => São redes exclusivamentes usadas para armazenamento e comunicação entre servidores.

PAN =>São redes que são usadas para conectar objetos próximos (Bluetooth).
PS: O “W” significa wireless, ou seja, essas redes com W antes são sem fio.

Classificação De Rede Quanto o Meio de Transmissão

Podemos dividir as redes em dois grandes grupos:redes cabeadas e redes sem fio.
Nas redes cabeadas as conexões entre dispositivos usam meios físicos como o cabo coaxial, o cabo de par trançado e o cabo de fibra óptica.
Tanto o cabo de par trançado quanto o cabo axial transportam o sinal eletromagnético, enquanto a fibra óptica o sinal é propagado pela luz.
Embora o par trançado seja mais flexível e barato, enfrenta o problema de interferências eletromagnéticas em maior escala. Já a fibra óptica, que é mais cara, está imune às interferências e possui a capacidade de atingir altas taxas de transmissão.

Nas redes sem fio o sinal é transmitido em espaço aberto não guiado.

A primeira demonstração pública de uma rede sem fio foi no Havaí e se chamava alohanet, o objetivo era usar equipamentos de rádio de baixo custo para conexões entre terminais de usuários até um grande computador central de uso compartilhado.

Peculiaridades e Características Das Redes Sem Fio

A troca de enlaces físicos por sem fio lhe confere algumas vantagens e desvantagens.

Vantagens

O lançamento de cabos em áreas urbanas ou rurais pode ser bastante complicado, custoso ou até proibido. Então em casos assim a rede sem fio pode ser uma vantagem ou até mesmo a única opção.
A mobilidade dos terminais.
Facilidade de expansão da rede e rapidez na instalação.

Desvantagens

Transmissão em espaço aberto traz preocupação com segurança por fácil captura do sinal.
Transmissão em espaço aberto também está sujeita a interferência e atenuação do sinal.
A propagação do sinal também sofre o que se chama de propagação multivias, o sinal pode sofrer reflexões em obstáculos físicos e climáticos pelo caminho.

Redes Locais sem Fio (WI-FI)

A tecnologia dominante empregada em redes locais sem fio é a tecnologia WiFi, identificada pelo padrão IEEE 802.11.
O BSS (BASIC SERVICE SET) é quando a estrutura é formada por um ponto de acesso central e todos os terminais se conectam nele.
Numa rede de wifi maior existem vários BSS’s conectados a um terminal central e damos a isso o nome de ESS(EXTENDED SERVICE SET)

Colisão de Redes

É quando dois transmissores ou mais sobrepõem o sinal um do outro e esse fenômeno embaralha o sinal dificultando a decodificação dos aparelhos. Por isso surge o protocolo CSMA fazendo o transmissor aguardar caso o espaço que ele iria usar para transmitir já estiver sendo usado por outro transmissor.
Quanto menor o tempo para transmitir, maior a prioridade do sinal e quanto maior o tempo menor a prioridade .(O tempo de transmissão do sinal e a prioridade de transmissão do sinal são inversamente proporcionais)

Redes Móveis de Celulares

A cobertura que essas redes oferecem nas grandes cidades, estradas e até mesmo em zonas rurais é bastante ampla, o que motivou a explosão do consumo e a utilização de aparelhos celulares como plataformas de acesso à Internet.
Handodolf é o nome dado à mudança de célula de cobertura ao se movimentar.
Uplink é o canal de comunicação dos terminais até a BS.
Downlink é o canal de comunicação da BS até os terminais.

Tipos em Typescript

João Costa — Sat, 30 Jul 2022 19:01:00 +0000

Pq usar Typescript??

Antes de entrar nos tipos básicos de typescript é importante saber o por que estamos fanzendo isso. Eu msm não era muito fã de acrescentar tipos no frontend por exemplo, porém depois de uma introdução curta vi que o superset do javascript poderia diminuir meus problemas tanto com troca de nome de propriedades quanto de prever partes do código que eu posso estar recebendo algo nulo e como iniciante eu achei isso realmente incrível.

Ps: Provavelmente deve haver outros fantásticos benefícios de se usar typescript, mas estou aplicando o learning public nesse texto então se houver mais descobriremos juntos.

Tipos do Typescript

Vamos começar pelos tipos primitivos que são os basicos e comuns do ecossistema.

Boolean

É o mais básico dos tipos, compreende somente os valores true e false.

const yes: boolean = true
const no: boolean =  false

Number e BigInt

Os dois tipos são para variáveis que vão receber números, porém o tipo number pode ser para qualquer número e o bigint só para números inteiros.

const BigNum1:bigint = 100n;           //ok
const BigNum2:bigint = 100.20n;        //error

const Num1:number = 100;               //ok
const Num2:number = 100.20;            //ok

Vc pode se perguntar por que?? Até pq eu me perguntei. E a resposta para existir dois tipos para números msm o tipo number aceitando todos é que o bitint consegue lidar melhor com números muito grandes.

String

Outro tipo que desenvolvedores javascript estão acostumados, é aplicado a variáveis que recebem cadeias de caracteres entre aspas assim como no javascript.

const firstName:string = "João";     //ok
const age:string = 19;              //error

Void, Null e Undefined

Muitas vezes null e undefined são confundidos pois a diferença é realmente bem sutil.Usando a inferência de tipo do typescript podemos ter uma ideia da diferença.

let a
let b=null
console.log(typeof(a))   //undefined
console.log(typeof(b))   //object

Undefined significa que o valor não foi atribuído e você não sabe seu valor . É uma ausência não intencional de valor . Isso significa que uma variável foi declarada, mas ainda não recebeu um valor.
Null indica que você sabe que o campo não possui um valor . É uma ausência intencional de valor. O console.log no exemplo retorna object por um bug conhecido no javascript.

E o void ?? Void é um tipo especifico para retorno de de funções que não retornam nada.

function fn1 ():void {
 console.log('Não retorna nd')      //ok
}
function fn2 (args:number):void {
 return args                       //error
}

Saindo dos tipos primitivos vamos conhecer algumas novidades que o typescript trouxe.

Date

Se vc usar o typeof com o construtor new Date no javascript vc verá [object object] no console. O typescript trouxe esse tipo que nos permite digitar variáveis de data com força e obter intellisense útil no objeto Date.

const date = new Date(1990, 4, 7)
console.log(typeof date)         //Date

Array

É um tipo genérico onde vc especifica que tipo de dado vai ser guardado pelo array. E há duas formas de usar esse genérico.

const numbers: Array<number> = [1, 2, 3]; // ok
const numbers: Array<number> = [1, 'two', 3]; // error

const numbers: number[] = [1, 2, 3]; // ok
const numbers: number[] = [1, 'two', 3]; // error

Tuple

São uma forma de tipar cada valor de um array.

const tomScore: [string, number] = ["Tom", 70];

Tbm podemos ultilizar o spread operator para esse tipo mais dinamico.

const tomScore: [string, ...number[]] = ["Tom", 70, 60, 80]];

Never

É um tipo que indica que uma função nunca deve retornar algo e é diferente do tipo void. Void consegue receber null e undefined já never não.

const something: void = null     //ok
const nothing: never = null      //error

Por esse rigor do tipo never normalmente se usa em funções que sempre geram um erro.

function fn(a: string | number): boolean {
  if (typeof a === "string") {
    return true;
  } else if (typeof a === "number") {
    return false;
  }  
  return neverOccur('Houve um erro');
}

function neverOccur (message: string) : never {
   throw new Error(message);
}

Unknown e Any

Lendo a documentação e conversando com desenvolvedores se acha algo que é consenso (se vc participa da bolha dev no twitter vc sabe o quanto é difícil): Não use any!! Óbvio que é um exagero a questão é tentar ao máximo não usar any e pq? Por que any desativa toda a checagem de tipos do seu código e isso ruim pq o typescript surge exatamente para garantir o type checking.
Por isso é preferível usar unknown e ultilizar de if para garantir a tipagem .
Não muito seguro

let something
something = "Bob";
something = 33;
something = false;
something = new Date(2019, 5, 8);

Seguro

function add(a: unknown, b: unknown) {
  if (typeof a === "number" && typeof b === "number") {
    return a + b;
  }
  return 0;
}

Espero que tenha ficado claro. Qualquer crítica, sugestão ou dúvida minha dm do twitter está aberta.

Hooks básicos do React(useState, useEffect, useContext)

João Costa — Tue, 22 Feb 2022 15:07:31 +0000

Hooks são recursos introduzidos na versão React 16.8. Ele nos permite usar o estado e outros recursos do React sem escrever uma classe.

useState

O hook useState nos permite criar variáveis de estado em um componente de função React.
O estado nos permite acessar e atualizar determinados valores em nossos componentes ao longo do tempo
Quando criamos uma variável de estado, devemos fornecer a ela um valor padrão.E podemos incluir o estado em qualquer lugar do componente.

import { useState } from 'react'

export default function App () {
 const [count, setCount] = useState (0)
 return <h1>{count}</h1>
}

E para atualizar basta fazermos um função usando o setCount para atualizar o estado.

import { useState } from 'react'

export default function App () {
 const [count, setCount] = useState (0)
 return ( 
   <div>
    <h1>{count}</h1>
    <button 
     type="submit"
     onClick={() => setCount(count + 1)
     >Adicionar</button>
   </div>
  )
}

useEffect

O useEffect Hook nos permite realizar efeitos colaterais em nossos componentes funcionais.O useEffect aceita dois argumentos, a função e o os paramêtros, o segundo sendo opcional.

import { useEffect, useState } from 'react'

export default function App () {
 const [count, setCount] = useState (0)
 useEffect(()=>{
  document.title = `Vc clicou ${count}x`
 },[])
 return (...)
}

Nesse exemplo o useEffect tem um array de dependências vazio e isso irá fazer com que o código dentro só execute um vez, quando o componente é montado.O que talvez não seja sua intenção se vc quer mostrar no title quantas vezes o botão foi clicado.

Para resolver isso basta colocar no array de dependências o count, assim o useEffect irá monitorá-lo e toda vez que detectar uma mudança em count executará a função, alterando o title da página.

import { useEffect, useState } from 'react'

export default function App () {
 const [count, setCount] = useState (0)
 useEffect(()=>{
  document.title = `Vc clicou ${count}x`
 },[count])
 return (...)
}

useContext

O useContext fornece a forma de compartilhar dados entre todos componentes da mesma árvore de componentes, sem precisar passar explicitamente props entre cada nível.

Criar contexto

Para criar contexto, você deve Importar createContext e inicializá-lo.

import { createContext } from 'react'
const UserContext = createContext()

Em seguida, usaremos o Context Provider para agrupar a árvore de componentes que precisam do estado Context.
Envolva os componentes filho no Provedor de Contexto e forneça o valor do estado.

import { createContext, useState } from 'react'
const UserContext = createContext()
export default function App () {
 const [user, setUser] = useState("Maria")
 return (
   <UserContext.Provider value={user}>
    <Component1/>
  </UserContext.Provider>
 )
}

Agora, todos os componentes desta árvore terão acesso ao user do Context.

import { useContext } from 'react'
export default function Component5 () {
 const user = useContext(UserContext)
 return (
  <>
   <h1>Componente 5</h1>
   <h2>Oi {user}, seja bem vindo</h2>
  </>
}

Map, Filter e Reduce em JavaScript

João Costa — Mon, 07 Feb 2022 14:46:55 +0000

O que são map, filter e reduce?

São funções no protótipo de um array JavaScript e podem ser usadas para operações baseadas em iterações em uma coleção de itens armazenados nesse array.

Map

Map é uma função que percorre o array e retorna um novo.

const numbers= [1, 2, 3, 4, 5];

const newArr= numbers.map(item => {
  return item * 2;
});

Então como map gera um novo array numbers retorna o mesmo array, enquanto newArr retorna outro array com os valores duplicados.

Filter

Filter é a função que retorna um array filtrado pelas condições que fornecemos.

const numbers = [1, 2, 3, 4, 5];

const newArr = numbers.filter(item => {
  return item % 2 === 0;
});

Pela condição que colocamos acima a função só irá retornar os números par.

Reduce

Reduce é a função que percorre o array e reduz ele a um único valor.

const numbers = [1, 2, 3, 4, 5];

const newArr = numbers.reduce((acc, item) => {
  acc = acc + item;
  return acc;
});

Reduce recebe dois argumentos o acumulador e o item atual. Cada item é adicionado ao acumulador antes que o acumulador seja retornado para a próxima passagem. Retornando em um valor de 15.