DEV Community: Douglas Alves

Migrating from Ingress NGINX to Gateway API on EKS

Douglas Alves — Wed, 10 Jun 2026 14:53:42 +0000

Photo by Shamin Haky on Unsplash

The ingress-nginx controller was retired in March 2026. That means no more security updates or bug fixes, so if you rely on NGINX as the ingress controller for your cluster, you need to act.

Worth mentioning : Only the ingress-nginx controller was retired. NGINX as a web server and the Kubernetes Ingress API remain supported.

Why not take the opportunity to modernize your EKS cluster with Gateway API? By the end of this article, you’ll understand what Gateway API is, how to configure its core and AWS-specific components, and how to migrate your existing workloads without any downtime.

Prerequisites

Before you start the migration, make sure you have:

AWS Load Balancer Controller v3.0 or later installed. GA support for Gateway API was released in v3.0.
EKS cluster running the Amazon VPC CNI plugin. IP-mode target groups require native VPC networking — if you’re using an overlay CNI like Calico in VXLAN mode, this won’t work.
The Gateway API CRDs installed in the cluster (upstream CRDs from gateway-api.sigs.k8s.io).
The AWS-specific CRDs installed: TargetGroupConfiguration, LoadBalancerConfiguration, and ListenerRuleConfiguration.

Understanding the Gateway API Features

Applying Gateway API to your cluster gives you clear ownership and portability. As an example, platform teams can manage infrastructure while app teams manage application routing. It also gives you portability, as core resources work across providers. That means no more vendor-specific annotation soup.

The basic components of Gateway API in EKS are the following:

GatewayClass — Defines which controller manages gateways of this type. Owned by the infrastructure provider (in our case, AWS Load Balancer Controller).
Gateway — Represents the actual load balancer instance. It declares listeners (ports, protocols, TLS), and references a GatewayClass (in our case, also a LoadBalancerConfiguration).
HTTPRoute — Defines the routing rules (paths, headers, weights). It references a Gateway.

AWS Custom Resources:

LoadBalancerConfiguration — Defines all aspects of a load balancer, including scheme (internet-facing or internal), default SSL certificate, WAF protections and others.
TargetGroupConfiguration — Defines all aspects of a target group, including target type (IP or node) and health check configurations. It references a Service and can define per-route health check.

Step 1 — Enable Gateway API support in the AWS Load Balancer Controller

The first step is to enable Gateway API support in the AWS Load Balancer Controller. If you’re using a helm installation (recommended), just change the values as follows and upgrade:

aws-load-balancer-controller:
  clusterName: <your-cluster-name>
  serviceAccount:
    create: true
    name: aws-load-balancer-controller
  controllerConfig:
    featureGates:
      NLBGatewayAPI: true # Enables L4 (TCP/UDP) routing via NLB
      ALBGatewayAPI: true # Enables L7 (HTTP/gRPC) routing via ALB

Step 2 — Install the CRDs

You need two sets of CRDs: the upstream Kubernetes Gateway API CRDs, and the AWS-specific ones.

Gateway API CRDs:

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.3.0/standard-install.yaml

AWS-specific CRDs (install from the AWS Load Balancer Controller repository — check the latest release tag):

kubectl apply -k "github.com/aws/eks-charts/stable/aws-load-balancer-controller/crds?ref=master"

Verify everything is in place:

kubectl api-resources | grep gateway.networking.k8s.io
kubectl api-resources | grep gateway.k8s.aws

You should see GatewayClass, Gateway, HTTPRoute, GRPCRoute in the first output, and LoadBalancerConfiguration, TargetGroupConfiguration, ListenerRuleConfiguration in the second.

Step 3 — The new AWS-specific CRDs

This is the biggest change when coming from Ingress on AWS. Everything you used to configure via annotations is now expressed through typed CRDs. This is strictly better — configuration errors surface at kubectl apply time instead of failing silently at runtime.

LoadBalancerConfiguration

Replaces annotations like alb.ingress.kubernetes.io/scheme, alb.ingress.kubernetes.io/subnets, alb.ingress.kubernetes.io/security-groups. It configures the ALB or NLB that backs your Gateway.

apiVersion: gateway.k8s.aws/v1beta1
kind: LoadBalancerConfiguration
metadata:
  name: internet-facing
  namespace: platform # Must be in the same namespace as your Gateway
spec:
  scheme: internet-facing
  listenerConfigurations:
    defaultCertificate: arn:aws:acm:us-east-1:xxxxxxxxxxxx:certificate/...
    protocolPort: HTTPS:443
  loadBalancerAttributes:
  - key: idle_timeout.timeout_seconds
    value: "305"
  wafV2:
    webACL: arn:aws:wafv2:us-east-1:xxxxxxxxxxxx:regional/webacl/...

TargetGroupConfiguration

Replaces alb.ingress.kubernetes.io/target-group-attributes, alb.ingress.kubernetes.io/healthcheck, and similar annotations. Attached to a Service.

apiVersion: gateway.k8s.aws/v1beta1
kind: TargetGroupConfiguration
metadata:
  name: api-tg-config
  namespace: my-app-ns
spec:
  targetReference:
    kind: Service
    name: api-service
  defaultConfiguration:
    targetType: ip
  routeConfigurations:
    - routeIdentifier:
        kind: HTTPRoute
        namespace: my-app-ns
        name: my-app-route
      targetGroupProps:
        healthCheckConfig:
          healthCheckPath: /healthz
          healthCheckPort: 8080
          healthCheckProtocol: HTTP
          healthyThresholdCount: 2
          unhealthyThresholdCount: 2
          healthCheckTimeout: 5
          healthCheckInterval: 15
          matcher:
            httpCode: "200"

Step 4 — Create the GatewayClass

The GatewayClass tells Kubernetes which controller manages gateways of this type. It’s a cluster-scoped resource — your platform team creates it once, and app teams reference it by name.

For ALB (L7):

apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: aws-alb
spec:
  controllerName: gateway.k8s.aws/alb

For NLB (L4):

apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: aws-nlb
spec:
  controllerName: gateway.k8s.aws/nlb

Step 5 — Create the Gateway

The Gateway represents your actual load balancer. It defines listeners and references a LoadBalancerConfiguration for AWS-specific settings.

apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: default-gateway
  namespace: platform # Must be in the same namespace as your LoadBalancerConfiguration
spec:
  gatewayClassName: aws-alb
  infrastructure:
    parametersRef:
      group: gateway.k8s.aws
      kind: LoadBalancerConfiguration
      name: internet-facing # Your LoadBalancerConfiguration
  listeners:
  - name: http
    protocol: HTTP
    port: 80
    allowedRoutes:
      namespaces:
        from: All
  - name: https
    protocol: HTTPS
    port: 443
    allowedRoutes:
      namespaces:
        from: All
    tls:
      mode: Terminate
      options:
        aws.amazon.com/acm-certificate-arn: arn:aws:acm:us-east-1:xxxxxxxxxxxx:certificate/...

After applying this, the AWS Load Balancer Controller provisions an ALB. Check the status:

kubectl get gateway default-gateway -n platform

The ADDRESS field will populate with the ALB's DNS name once it's PROGRAMMED: True. This takes 1-2 minutes.

Step 6 — Create HTTPRoutes for your applications

HTTPRoute is where your application teams live. It maps to the routing rules you had in your Ingress spec, but without the annotation noise.

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: my-app-route
  namespace: my-app-ns
spec:
  parentRefs:
    - group: gateway.networking.k8s.io
      kind: Gateway
      name: default-gateway
      namespace: platform # Cross-namespace reference to the shared Gateway
      sectionName: https # Attach to the HTTPS listener specifically
  hostnames:
    - "myapp.example.com"
  rules:
    - matches:
        - path:
            type: PathPrefix
            value: /api
      backendRefs:
        - name: api-service
          port: 8080
    - matches:
        - path:
            type: PathPrefix
            value: /
      backendRefs:
        - name: frontend-service
          port: 3000

Traffic splitting is now native. Just set a weight on each backendRef:

rules:
    - backendRefs:
        - name: my-app-v1
          port: 8080
          weight: 90
        - name: my-app-v2
          port: 8080
          weight: 10

The migration strategy: no downtime required

Don’t delete your NGINX Ingress resources first. Here’s the safe path:

1. Run both controllers in parallel

Deploy the Gateway API resources alongside your existing NGINX Ingress. They’ll get different AWS load balancer endpoints. Your NGINX Ingress keeps serving production traffic.

2. Test the Gateway endpoint

After your Gateway and HTTPRoute resources are applied and the ALB is PROGRAMMED, test it directly by hitting the ALB DNS name with a Host header:

curl -H "Host: myapp.example.com" http://<alb-dns-name>/api/healthz

3. Shift traffic progressively via weighted DNS

Update your DNS record to use weighted routing (Route 53 weighted records work perfectly here). Start with 5–10% of traffic going to the new ALB, watch your metrics and error rates, then gradually shift to 100%.

4. Clean up NGINX resources

Once 100% of traffic is on the Gateway API path and you’ve monitored for a stability period, remove your Ingress resources and eventually the NGINX controller itself.

Common pitfalls

Internal ALB instead of internet-facing. If you don’t explicitly set scheme: internet-facing in your LoadBalancerConfiguration, you get an internal ALB that's not reachable from the internet. This is the single most common "why isn't it working" issue.
LoadBalancerConfiguration in the wrong namespace. When attaching a LoadBalancerConfiguration to a Gateway, it must be in the same namespace as the Gateway. Cross-namespace references are not supported here.
Feature gates not enabled. If your Gateway stays in a Pending state and the controller logs show nothing about it, check that ALBGatewayAPI: true is in your feature gates. The controller silently ignores Gateway resources when the feature is disabled.
VPC CNI required for IP mode. If you’re using a non-VPC-native CNI, IP-mode target groups won’t work. You can use NodePort services with instance target type, but you lose the pod-level routing precision.
Always check status conditions. Check the status field of your Gateway and HTTPRoute resources — the controller writes detailed conditions there, including the ALB DNS name, ARN, and any reconciliation errors.

kubectl describe gateway default-gateway -n platform
kubectl describe httproute my-app-route -n my-app

Conclusions

Gateway API on EKS is genuinely better than Ingress. The role separation between GatewayClass, Gateway, and HTTPRoute maps cleanly to how platform teams and application teams actually work. The typed CRDs (LoadBalancerConfiguration, TargetGroupConfiguration) replace annotation soup with something you can actually validate. And the routing capabilities — header-based routing, traffic splitting, gRPC support — are built in rather than bolted on.

The migration itself is less scary than it looks. Run both in parallel, shift DNS progressively, and clean up when you’re confident. The NGINX controller retirement is a forcing function, but it’s also a good excuse to modernize your cluster networking in a way you’ll appreciate for years.

Have questions or suggestions? Let me hear your thoughts in the comments — I’m happy to help and discuss!

Resources:

Understand Graphs and Trees with JavaScript

Douglas Alves — Mon, 30 Jan 2023 13:30:42 +0000

Understanding Graphs and Trees with JavaScript

Photo by Mila Tovar on Unsplash

In the last article, I introduced the principal data structures like stacks, queues, and hash tables. This article is a second part where I will explain two important data structures: graph and tree, demonstrating how you can implement them with JavaScript.

If you haven’t read the first part, please click here to read it before further reading the second part.

Understanding Graphs

A graph is a structure used to represent non-linear relationships between objects. Graph objects are named nodes (or vertices), and the relationships between objects are named edges. The number of edges connected to a node is called a degree.

Graphs are essential to represent complex data relationships and have many applications in diverse fields like logistics, gene mapping, and air traffic control.

A sequence of nodes connected by edges is named a path. When the path starts and ends on the same node, it’s named a cycle.

When the edges in a graph have a single direction, the graph is called a directional graph (digraph). When the edges are bi-directional, the graph is called an undirected graph.

We can also assign values to the edges. In that case, the graph is called a weighted graph. An example of a weighted graph is an airway map, where the waypoints are the nodes, the routes connecting the waypoints are the edges, and the distances between waypoints are the weights.

Part of the Brazil en-route chart, available at decea.mil.br

How to implement graphs

There are two main techniques to represent a graph: adjacent matrix , which uses a matrix listing all nodes horizontally and vertically, adding a number in the intersections representing the edges connecting the nodes, and adjacent list , which uses a list containing the reference of nodes connected by edges.

We can implement an undirected graph with adjacent lists in JavaScript by creating two classes as follows:

Let’s start by creating the Node class.

export class Node {
  constructor(value) {
    this.adjacentNodes = new Set();
    this.value = value;
  }

  getAdjacentNodes() {
    return this.adjacentNodes;
  }

  addAdjacentNode(node) {
    if (!this.adjacentNodes.has(node)) {
      return this.adjacentNodes.add(node);
    }
  }

  removeAdjacentNode(node) {
    return this.adjacentNodes.delete(node);
  }
}

The Node class has the properties adjacentNodes (a set of adjacent nodes) and value (the node value), and the methods getAdjacentNodes, addAdjacentNode, and removeAdjacentNode to get, add, and remove adjacent nodes.

Next, create the Graph class as follows:

import { Node } from "./node.js";

class Graph {
  constructor() {
    this.nodes = new Map();
  }

  addNode(value) {
    if (!this.nodes.has(value)) {
      const node = new Node(value);
      this.nodes.set(value, node);
    }
  }

  removeNode(value) {
    const currentNode = this.nodes.get(value);

    if (this.nodes.has(value)) {
      for (const node of this.nodes.values()) {
        node.removeAdjacentNode(currentNode);
      }
    }
    this.nodes.delete(value);
  }
}

In the implementation above, we are using a Map object to store the graph nodes. The JavaScript map class provides all the advantages of the hash table explained in the last article.

The class also has the method addNode, for creating new nodes and adding them to the nodes map, and the method removeNode, for removing the node from all adjacent lists and then removing it from the nodes map.

We also need to create methods for adding and removing edges in the Graph class as follows:

addEdge(sourceValue, destinationValue) {
    const source = this.nodes.get(sourceValue);
    const destination = this.nodes.get(destinationValue);

    if (source && destination) {
      source.addAdjacentNode(destination);
      destination.addAdjacentNode(source);
    }
 }

 removeEdge(sourceValue, destinationValue) {
    const source = this.nodes.get(sourceValue);
    const destination = this.nodes.get(destinationValue);

    if (source && destination) {
      source.removeAdjacentNode(destination);
      destination.removeAdjacentNode(source);
    }
  }

In an undirected graph with adjacent lists, we define edges by adding the source and destination nodes to the adjacent list of each node.

In the example above, the method addEdge receives the source and destination values, searches for each node in the nodes map, and adds the corresponding nodes to the adjacent lists. The method removeEdge is very similar, but instead of adding the nodes, it will remove nodes from the adjacent lists.

A practical example

Imagine you want to represent the following graph:

You can represent the graph as in the following example:

const graph = new Graph();

const nodes = new Set(["A", "B", "C", "D", "E"]);

for (const node of nodes.values()) {
  graph.addNode(node);
}

graph.addEdge("A", "B");
graph.addEdge("A", "E");

graph.addEdge("B", "C");
graph.addEdge("B", "D");

graph.addEdge("C", "E");
graph.addEdge("C", "D");

graph.addEdge("D", "E");
graph.addEdge("E", "A");

/* Adjacent lists:
 * A > ["B", "E"];
 * B > ["A", "C", "D"];
 * C > ["B", "E", "D"];
 * D > ["B", "C", "E"];
 * E > ["A", "C", "D"];
 */

Now, let’s understand another useful type of graph named tree.

Understanding Trees

A tree is a specific type of graph. We say it’s a tree when the graph is undirected, has no cycles, and all nodes are connected. The first node in a tree is named root, the last node in a path is named leaf , and the path connecting the root node to a leaf node is named branch. The number of edges connecting the root to the more distant leaf is named height.

Trees are used for solving diverse problems like building other data structures, fast searching algorithms, and machine learning models.

You can implement different versions, depending on the problem you need to solve, such as binary search trees , expression trees , and balanced trees.

A tree is a type of graph, so you can also use the techniques explained before ( adjacent matrix and adjacent list).

Graph and tree traversal algorithms

Graph traversal is the process of visiting each node in a graph. There are various traversal algorithms for specific uses. I’ll explain the breadth-first search (BFS) and depth-first search (DFS), which you can use to traverse both a graph and a tree.

How to implement a breadth-first search

The BFS algorithm starts in a given node and visits all the adjacent nodes before proceeding. In a tree, the starting node must be the root.

We can implement the BFS algorithm using a queue and registering all visited nodes in a list, as in the following example:

  bfs(firstNode) {
    const nodesVisited = new Set();
    const visitQueue = new Queue();

    visitQueue.add(firstNode);

    while (!visitQueue.isEmpty()) {
      const node = visitQueue.dequeue();

      if (node != "Empty" && !nodesVisited.has(node)) {
        nodesVisited.add(node);
        node
          .getAdjacentNodes()
          .forEach((adjacentNode) => visitQueue.add(adjacentNode));
      }
    }
  }

In the example above, we’re adding the first node to the visitQueue and iterating over the queue until it’s empty. In each iteration, we dequeue the node placed in front, add it to the nodesVisited set, and add all adjacent nodes to the visitQueue. With this method, all nodes will be visited following the order FIFO (first-in, first-out).

How to implement a depth-first search

The DFS algorithm starts in a given node, but instead of visiting all adjacent nodes like in the BFS algorithm, it will visit the following nodes in the path before proceeding.

We can implement the DFS algorithm the same way as BFS, but instead of using a queue, we must use a stack, as in the following example:

 dfs(firstNode) {
    const nodesVisited = new Set();
    const visitStack = new Stack();

    visitStack.push(firstNode);

    while (!visitStack.isEmpty()) {
      const node = visitStack.pop();

      if (node != "Underflow" && !nodesVisited.has(node)) {
        nodesVisited.add(node);
        node
          .getAdjacentNodes()
          .forEach((adjacentNode) => visitStack.push(adjacentNode));
      }
    }
  }

With this method, all nodes will be visited following the order LIFO (last-in, first-out).

Next steps

Graphs and trees are complex data structures. It’s challenging to resume all this knowledge in one article, so I recommend you to keep studying, and to help you in this journey, check these free resources:

Graph implementations : https://isaaccomputerscience.org/concepts/dsa_datastruct_graph_implementation?examBoard=all&stage=all&topic=data_structures
Tree implementations : https://isaaccomputerscience.org/concepts/dsa_datastruct_tree?examBoard=all&stage=all&topic=data_structures

Conclusion

Thank you for reading! I hope this article has interesting and informative to you. Let me know your thoughts in the comments section, and consider following me for more articles like this.

Understanding Data Structures with JavaScript

Douglas Alves — Sun, 04 Dec 2022 22:47:52 +0000

Photo by Alina Grubnyak on Unsplash

Data structures are the foundation of computer science and programming. We use data structures for retrieving, organizing, processing, and storing data. By learning the different data structures, you can become a better developer, comparing algorithms, choosing wisely libraries to use in each scenario, and implementing outstanding and cost-effective solutions.

A deep understanding of data structures is also an excellent skill for technical interviews in big companies.

In this article, I will explain the principal data structures and demonstrate how to implement them with JavaScript, but you can apply its concepts in any programming language.

Understanding Sets

A set is a collection of unique elements of any type. It can contain strings, numbers, objects, and even other sets. The concept of sets comes from set theory , and we can easily implement the operations for manipulating them with JavaScript.

To create sets in JavaScript, we can use the Set() class:

const set = new Set();

set.add({ value: 3, weight: 2 });
set.add("string");
set.add(true);

console.log(set);

// Output: Set(3) { { value: 3, weight: 2 }, 'string', true }

To implement set operations, we can use the Set() class methods as follows:

// Union
const union = (firstSet, secondSet) => {
  const setUnion = new Set(firstSet);

  for (const element of secondSet) {
    setUnion.add(element);
  }
  return setUnion;
};

// Intersection
const intersection = (firstSet, secondSet) => {
  const setIntersection = new Set();

  for (const element of secondSet) {
    if (firstSet.has(element)) setIntersection.add(element);
  }
  return setIntersection;
};

// Difference
const difference = (firstSet, secondSet) => {
  const setDifference = new Set(firstSet);

  for (const element of secondSet) {
    setDifference.delete(element);
  }
  return setDifference;
};

You can use sets to implement various algorithms and even other data structures. Different from arrays, sets are flexible data structures you can use to store any kind of data.

Understanding Stacks

A stack is a collection of elements where the insertion and removal follows a specific order ( last-in, first-Out ). The concept of stacks comes from queuing theory. Like a stack of plates, where you can’t remove the plate at the bottom, in a stack, you can only add or remove an item at the top of the stack.

We can implement stacks with a dynamic structure, which doesn’t have a fixed size and can grow dynamically, or with a static structure, which has a fixed size and can’t store more items them a defined limit.

To implement stacks with static structure in JavaScript, we can create a new class as follows:

export class Stack {
  constructor(maxLength) {
    this.items = new Array();
    this.maxLength = maxLength;
  }

  push(item) {
    if (this.isFull()) return "Overflow";
    else return this.items.push(item);
  }

  pop() {
    if (this.isEmpty()) return "Underflow";
    else return this.items.pop();
  }

  peek() {
    return this.items[this.items.length - 1];
  }

  isEmpty() {
    return this.items.length === 0;
  }

  isFull() {
    return this.items.length === this.maxLength;
  }
}

const stack = new Stack(3);

stack.push(100);
stack.push(101);
stack.push(102);
stack.pop();

console.log(stack.peek());

// Output: 101

Use case

Now, let’s see a simple example of how to use a stack. Imagine you are developing a text editor and it needs to track the last file changes, so users can undo or redo the changes. You can use a stack to track file changes as follows:

import { Stack } from "./stack.js";

export class Editor {
  constructor() {
    this.lastChanges = new Stack(50);
  }

  async write(writable, input) {
    await writable.write(input);

    return this.lastChanges.push(input);
  }

  async undo(writable) {
    const lastChange = lastChanges.peek();

    await writable.remove(lastChange);
    return this.lastChanges.pop();
  }

  async redo(writable, input) {
    return await this.write(writable, input);
  }
}

In the example above, whenever we write an input to the file, the method also adds the change to the lastChanges stack invoking the method push().

Whenever we undo a file change, the method gets the last change by invoking the method peek(), next remove it from the file, and remove it from the lastChanges stack by invoking the method pop().

Understanding Queues

A queue is a collection of elements where the insertion and removal follows a specific order. Stacks and queues are similar, but different from stacks, queues are first-in, first-out structures, which means the first element to be added will be the first element to be removed.

Depending on the requirements, we can implement a circular queue , which is a queue that reuses empty slots. Circular queues need to manage the free space in an array by pointing to the front and back indexes after enqueueing or dequeuing an element.

We can also implement a priority queue, where some items have priority over others. In that case, we must enqueue an item with high priority in front of items with low priority.

To implement linear queues with static structure in JavaScript, we can create a new class as follows:

export class Queue {
  constructor(maxLength) {
    this.items = new Array();
    this.maxLength = maxLength;
  }

  enqueue(item) {
    if (this.isFull()) return "Full";
    else return this.items.push(item);
  }

  dequeue() {
    if (this.isEmpty()) return "Empty";
    else return this.items.shift();
  }

  front() {
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }

  isFull() {
    return this.items.length === this.maxLength;
  }
}

Use case

Now, let’s see an example using a queue. Imagine you are developing a feed with an infinite scroll for a social media app. As the user scrolls down the feed, you need to simultaneously load new posts and unload posts already seen, for performance reasons. You can use a queue to load and unload the posts as follows:

import { Queue } from "./linearQueue.js";

export class Feed extends Queue {
  constructor(height) {
    super(height);
  }

  get() {
    if (this.isEmpty()) return "The feed is empty";
    else return this.items;
  }

  async load() {
    const post = await fetch("https://api.co/userfeed/post/");

    return this.enqueue(post);
  }

  unload() {
    return this.dequeue();
  }
}

In the example above, we can invoke the load() and unload() methods to display the posts correctly as the user scrolls down the feed, loading new posts and removing those already seen.

Understanding Hash Tables

A hash table is a structure that stores data in key-value pairs, hashing the key and storing it as an index. The algorithm applied to convert the key in a hash value is called hash function. Hash tables are especially useful when you need fast searching.

A common problem with hash tables is collisions, which occur when the hash function produces the same hash for different keys.

We can handle collisions with two different methods: linear probing and chaining. I won’t explain these methods in this article, but I recommend you to go deeper into this topic as probably you will have to deal with collisions.

We can easily implement a hash table in JavaScript by creating a class as follows:

export class HashTable {
  constructor() {
    this.size = 0;
    this.table = new Array(255);
  }

  #hash(key) {
    let hash = 0;

    for (let index = 0; index < key.length; index++)
      hash += key.charCodeAt(index);

    return hash % this.table.length;
  }

  set(key, value) {
    const index = this.#hash(key);

    this.table[index] = { key, value };
    this.size++;
  }

  get(key) {
    const index = this.#hash(key);
    return this.table[index];
  }

  remove(key) {
    const index = this.#hash(key);

    if (this.table[index]) this.table[index] = undefined;

    this.size--;
  }
}

In the implementation above, the hash function is a private method that gets the ASCII code of every character of the key and applies the remainder operator to ensure that the hash key is in the valid range of table indexes (as the table is an array with limited size), producing a numeric index for every key-value pair stored.

Use cases

A classic use case of hash tables is database indexing. Hash tables can be used in database engines to create indexes of specified columns in database tables so that it doesn’t need to scan entire tables when querying.

Hash tables can also be used to create in-memory caching systems, where the data needs to be stored and retrieved really fast.

Next steps

There are other important data structures in addition to those explained. In the next post, I will explain graphs and trees with examples and use cases using JavaScript, so if you are interested subscribe so you don’t miss the article.

To help deepen your knowledge of the data structures explained, I recommend these free resources:

Sets operations : https://isaaccomputerscience.org/concepts/data_numsys_set_operations
Stacks : https://isaaccomputerscience.org/concepts/dsa_datastruct_stack
Queues : https://isaaccomputerscience.org/concepts/dsa_datastruct_queue
Hash tables : https://isaaccomputerscience.org/concepts/dsa_datastruct_hash_table

Conclusion

Thanks for reading! Keep studying the different data structures and don’t miss my next article where I will explain trees and graphs with JavaScript. Let me know your thoughts in the comments section, and consider following me for more articles like this.

Building your First Node.js Project

Douglas Alves — Sat, 29 Oct 2022 18:48:02 +0000

When learning a new programming language, it’s common to find several questions in our minds and a sea of content to navigate. You can face trouble searching for a path to follow, but don’t worry! I will explain some concepts to help you get started on the right foot with Node.js!

First of all, what is Node.js?

Node.js is a JavaScript execution environment that runs outside a browser. In other words, you can run JavaScript directly in your operating system. It runs under the V8 engine, the Google Chrome JavaScript engine.

Beyond running your scripts, Node.js offers a series of tools that transform JavaScript into a complete programming language.

What is npm?

When you install Node.js, you will notice it also installs npm , the Node Package Manager. We use npm to install and manage our project dependencies.

You can find anything you can think of in the constantly growing npm library.

Here are some npm commands for you to get familiar with:

To start a project: npm init
Install a new package: npm install <>
Remove a package: npm remove <>
Run the project: npm start

Understanding the package file

The package.json is the main file of a Node.js project. In this file, you define your project metadata, the dependencies (packages your project need), and other features as scripts to run and debug your project.

These are some sections of package.json that you should know at the beginning:

Metadata : general information about the project. This section is essential when publishing the project on package registries.

Scripts : these are shortcuts you can use with npm to automate and make your work easier. For example, you can type npm start instead of node index.js to run the project. Scripts are essential when using tools that require complex commands.

Whenever you create a script (except in the cases of the start script), you should run it as follows: npm run << your script >>.

Dependencies : npm will record the packages used in your project in this section when you install them using the command npm install <> --save. Notice that you must add the flag --save to record a package reference.

After running the command npm install, npm will create a folder named node_modules in your project to store the dependencies.

Hands-on!

Now that you know the basics, let’s build the famous hello world example with Node.js:

First, install Node.js on your computer.
Next, create a new folder named my-project by running the following command: mkdir my-project && cd my-project
Inside the folder my-project , run the command npm init and type the information required to create a new project:

Creating a new project with npm

Next, create a new file named index.js and paste the following code:

Create the script to start the project in the package.json file as follows: "start": "node index.js"
Finally, start the project by running npm start, and access http://localhost:3000 in your browser.

Running a simple HTTP server

I recommend you change the code, rerun the project, and explore the results in your browser.

Next steps

To do well in Node.js, you must master JavaScript, especially in more recent versions (ES6+).

Another important tip is to keep an eye on TypeScript, a superset of JavaScript that adds features like types and static code analysis, which will save you a lot of time by describing errors and more.

To help you in this journey, I recommend these free resources:

W3Schools: https://www.w3schools.com/nodejs/
Node.js documentation: https://nodejs.dev
Mozilla Developer Network: https://developer.mozilla.org/pt-BR/docs/Web/JavaScript

Conclusion

Thanks for reading! Keep studying, and soon you will master JavaScript and Node.js. Let me know your thoughts in the comments section, and consider following me for more articles like this.

Enhance your Ubuntu experience with Gnome Software and Flatpacks

Douglas Alves — Mon, 26 Sep 2022 14:49:53 +0000

Ubuntu recently updated to version 22.04 LTS with Gnome 42, improving user experience and performance. We now have more touchpad gestures, power settings directly from the panel menu, smoother and polished animations, theme color customization, and more. However, Canonical has kept something that makes some users uncomfortable: the Snap store.

If you are one of the Ubuntu users looking for how to make your experience with managing apps as good as all the Ubuntu 22.04 interface, this post is for you. I will explain how you can remove the Snap store, install Gnome Software and use Flatpacks.

Why people don’t like the Snap store

Unfortunately, the Snap store (Ubuntu Software) doesn’t offer a user experience on par with Ubuntu. It is common to find developer test packages and pages that don’t display images correctly or don’t show the correct information about an app when browsing the store. Some apps also seem slowly loaded when installed as a Snap package.

Don’t get me wrong, I think Snap is an exciting project, but it could use some user experience improvements, especially the store (Ubuntu Software).

What is Flatpack?

Flatpack, similar to Snap, is a popular distribution package format. You can easily find apps on Flathub, its official store with thousands of packages. Flatpack also has an advantage over Snap in app load time and provides a great user experience with Gnome Software.

Installing Spotify from Flathub with Gnome Software

Now, let’s see how you can use Flatpack’s integration with Gnome Software to enhance your experience managing apps on Ubuntu.

Removing the Snap store

First, we’ll remove the apps installed with Snap, as we want to reinstall them with Flatpack. For listing all the apps installed, run the following command in the terminal:

$ snap list

Some packages listed are part of the Snap integration with Ubuntu, like bare core*, snapd, and snapd-desktop-integrations, don’t remove those if you want to keep the support for snaps in your system.

Now, run the following command to remove the apps installed:

$ sudo snap remove <<snap name>>

Next, remove the Snap store by running the following command:

$ sudo snap remove snap-store

After removing the Snap store and all apps installed with Snap, let’s install Gnome Software for managing our apps.

Installing Gnome Software

For installing Gnome Software, run the following command in the terminal:

$ sudo apt install gnome-software gnome-software-plugin-flatpack

This command will install Gnome Software, Flatpack, and the Flatpack plugin for Gnome Software.

Next, let’s add the Flathub repository to Ubuntu by running the following command:

$ flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Now, remove the Snap plugin by running the following command:

$ sudo apt remove gnome-software-plugin-snap

Finally, restart Ubuntu, and done! Search for Software in the applications menu to access Gnome Software:

Accessing Gnome Software from the applications menu

You can reinstall your apps and receive updates from Flathub on Gnome Software. You can even manage OS updates on the updates tab.

Conclusion

As you can see, it’s easy to install Gnome Software and Flatpacks on Ubuntu. Thanks for reading! Let me know your thoughts in the comments section, and consider following me for more articles like this.