DEV Community: Evan Loria

Optimizing Top K Frequent Elements in JavaScript Using a Max-Heap

Evan Loria — Wed, 09 Apr 2025 17:59:08 +0000

The Problem

The Top K Elements algorithm helps find the k most frequent elements in a list. A naive solution involves storing all elements and their frequencies as tuples in an array, sorting the array by frequencies in decreasing order, and then returning the first k elements. While this works fine for small datasets, it becomes inefficient as the dataset grows. We can optimize this approach by using a binary heap, which will allow us to store only the top k elements and significantly improve the time complexity.

Naive Solution Steps

Create a frequency map (using an object) to store the elements and their frequencies.
Convert the frequency map into an array of [element, frequency] pairs.
Sort the array in decreasing order based on the frequency of elements.
Slice the array to extract the top k elements.
Return the elements by mapping over the sliced array and retrieving only the elements (ignoring their frequencies).

function naiveTopK(list, k) {
  // Create an object of element frequencies
  const freqMap = {};
  for (const elem of list) {
    freqMap[elem] = (freqMap[elem] || 0) + 1;
  }
  // Convert frequencies object into an array of tuples
  const freqArr = Object.entries(freqMap);
  // Sort the frequenciesArr in descending order
  const sortedArray = freqArr.sort((a, b) => b[1] - a[1]);
  // Slice and map over the top k elements to return top k occurring
  return sortedArray.slice(0, k).map((tuple) => {
    return tuple[0];
  });
}

Efficiency Issues of the Naive Solution

The time complexity of the naive solution is O(n log n), meaning that as the size of the dataset (n) increases, the execution time increases at an accelerating rate. The primary issue with this approach is that it requires storing and sorting the entire array of elements, which becomes inefficient with larger datasets.

A binary heap is a binary tree data structure that satisfies the heap property. In a max-heap, each node's value is greater than or equal to the values of its children, while in a min-heap, each node's value is less than or equal to the values of its children. By using a binary heap to store only the top k most frequent elements, we can significantly improve time complexity. This optimized solution reduces the complexity to O(n log k), where k is the number of elements we need to track, leading to better performance with larger datasets.

Create a MaxHeap Class

We will implement a MaxHeap class to efficiently store the top k elements of the list. The class will include several methods:

size: Returns the current number of elements in the heap
push: Adds a new element to the heap
pop: Removes the root (largest element) of the heap and returns it
removeLast: Removes the last element in the heap array (assumed to be the least frequent due to insertion order)
_heapifyUp: Balances the heap when new elements are added, ensuring the max-heap property is maintained
_heapifyDown: Balances the heap when the root is removed, ensuring the max-heap property is maintained

// Create a MaxHeap class
class MaxHeap {
  constructor() {
    this.heap = [];
  }
  size() {
    return this.heap.length;
  }
  push(item) {
    this.heap.push(item);
    // Ensure the heap is balanced
    this._heapifyUp();
  }
  removeLast() {
    this.heap.pop();
  }
  pop() {
    if (this.size() === 0) return null;
    // Store the old root to be returned
    const root = this.heap[0];
    // Reassign the root to the last element to maintain the heap structure
    this.heap[0] = this.heap[this.size() - 1];
    // Remove the last element from the heap since it is now a duplicate
    this.heap.pop();
    // Ensure the heap is balanced
    this._heapifyDown();
    return root;
  }
  // Ensure the max heap maintains balance by making sure element is added in the correct place
  _heapifyUp() {
    // Start with the last element (this is where new elements are inserted)
    let index = this.size() - 1;
    // While the index is greater than 0
    while (index > 0) {
      // Find the parent index
      const parentIndex = Math.floor((index - 1) / 2);
      // If parent is greater than child the heap property is satisfied and we can stop
      if (this.heap[parentIndex][1] > this.heap[index][1]) {
        return;
      } else {
        // Flip the parent and child elements
        [this.heap[index], this.heap[parentIndex]] = [this.heap[parentIndex], this.heap[index]];
        // Set the index to the parent index
        index = parentIndex;
      }
    }
  }
  // Keep balance of the heap when the root is removed
  _heapifyDown() {
    let parentIndex = 0;
    const length = this.size();
    // While there is at least one child
    while (2 * parentIndex + 1 < this.size()) {
      // We assume the largest element index is at the front
      let largestElemIndex = parentIndex;
      const leftIndex = 2 * parentIndex + 1;
      const rightIndex = 2 * parentIndex + 2;
      // Check if left child frequency is larger than the current largest
      if (this.heap[leftIndex][1] > this.heap[largestElemIndex][1]) {
        // Reassign the current largestElemIndex
        largestElemIndex = leftIndex;
      }
      // Check if right child exists and is larger than the current largest
      if (rightIndex < length && this.heap[rightIndex][1] > this.heap[largestElemIndex][1]) {
        // Reassign the current largestElemIndex
        largestElemIndex = rightIndex;
      }
      // If largest is not the current node (one of the children was larger than the parent), swap and continue
      if (largestElemIndex !== parentIndex) {
        // Swap the current largest with the parent
        [this.heap[parentIndex], this.heap[largestElemIndex]] = [this.heap[largestElemIndex], this.heap[parentIndex]];
        // Reassign the parentIndex to the largestElemIndex
        parentIndex = largestElemIndex;
      } else {
        return; // No swap needed, heap is in valid state
      }
    }
  }
}

Optimized Solution

Once our MaxHeap class is configured, we can create an instance of the class in order to store our top k elements. This prevents us from having to eventually sort every element in the list.

function optimizedTopK(list, k) {
  // Create an object of element frequencies
  const freqMap = {};
  for (let elem of list) {
    // Add the elements to freqMap or increase the frequency count
    freqMap[elem] = (freqMap[elem] || 0) + 1;
  }
  // Create an instance of MaxHeap to store the most frequent elements
  const heap = new MaxHeap();
  // Add the tuples to the heap
  for (const [num, freq] of Object.entries(freqMap)) {
    heap.push([num, freq]);
    // Check if the heap's size exceeds the desired number of top elements (k)
    if (heap.size() > k) {
      heap.removeLast();
    }
  }
  // Return the most frequent elements from the heap
  return heap.heap.map(elem => elem[0])
}
console.log(optimizedTopK([1, 1, 1, 2, 2, 3], 2)); // Output: ['1', '2']

_heapifyUp and _heapifyDown

These methods ensure that the max-heap property is maintained, meaning each parent element is greater than or equal to its children, whenever an element is added or removed from the heap.

The _heapifyUp method is called whenever a new element is added to the heap. It starts from the newly added element and moves upwards, comparing its frequency with its parent's frequency. If the new element's frequency is greater than its parent's, the two elements are swapped. This process continues until the max-heap property is satisfied, meaning the parent element is greater than or equal to the child.

The _heapifyDown method is used when the root is removed from the heap. In this solution, we never remove the root, so _heapifyDown isn’t called. However, if we were using pop()—for example, in a variation of this algorithm or a min-heap version—we’d rely on _heapifyDown to maintain heap order. It checks if either of the two child nodes has a greater frequency than the parent. If one of the child's frequencies is greater than the parent's, the elements are swapped, and the process repeats until the heap property is restored.

Conclusion

The naive solution to the Top K Elements problem works fine for smaller datasets, but as the dataset grows, sorting the entire list becomes inefficient. By implementing a max-heap, we can avoid sorting the entire list and instead focus on maintaining just the top k elements. This optimization reduces our time complexity from O(n log n) to O(n log k), significantly improving performance for larger datasets.

node-cron: Automation in node.js

Evan Loria — Sun, 09 Feb 2025 19:14:21 +0000

Introduction

Automation is vital in a Node.js environment. The NPM node-cron package allows developers to schedule tasks to run at regular intervals, automating anything from database backups to daily reports. This is achieved using cron syntax, a standard format used to define the schedule in which a job should run. Automating tasks within an application saves time, increases efficiency, and removes human error from repetitive or tedious tasks.

Use Cases

node-cron is great for scheduling jobs that need to be run at regular intervals. These tasks may include system maintenance, data processing and management, or removing temporary files to save disk space and system memory. Any job that needs to run routinely can be done so reliably with node-cron.

Crontab and Cron Syntax

Crontab, which is short for 'cron table', is a file used in Unix-like systems to store scheduled tasks. node-cron uses the same syntax for defining the intervals for application tasks. Cron syntax is a string of 5 date/time fields that tell the system when the jobs should be executed.

Fields

minute: 1-59
hour: 0-23
day of month: 1-31
month: 1-12
day of week: 0-7 (Sunday is 0 and 7)

node-cron offers an optional seconds field that is placed at the beginning of the cron expression. This is not standard for implementations of crontab syntax.
An asterisk (*) is used to represent any possible value of the field. For example, the following cron expression would run a task every minute:
* * * * *
This cron expression runs a task everyday at 12:00 pm:
0 12 * * *

Rather than using numbers to represent the month and day of the week, these fields can be spelled out or abbreviated.
These fields are not case sensitive.

'* * * january MON' // Every monday in january
'* * * jan monday' // Every monday in janaury

In addition, more than one option can be given to a field by supplying a comma separated list.

'0,15 12,1 * * MON,WED' 
Every Mon & Wed at 12:00, 12:15, 1:00, and 1:15

Ranges and Steps

node-cron allows for ranges and steps to be applied to the fields. Ranges are applied using a dash (-) and steps are supplied with a slash (/) followed by the step to increment by. For example, to run a task only during the work week (Monday to Friday), you could use MON-FRI in the day of the week field. Similarly, to run a task every minute from minute 30 through minute 45 of an hour, use the expression '30-45 * * * *'.

Every minute between 12:00 and 12:30 Mon-Fri
'0-30 12 * * MON-FRI' 
At midnight on the 1st of every month January-June
'0 0 1 1-6 *'
Every 5 minutes on Monday
'*/5 * * * Mon'
Every 2 months at 12:00 pm
'0 12 * */2 *'

Steps can also be applied to ranges

Every other day, every other month between Jan-Aug every 3 hours between 6:00am and 12:00pm
'0 6-12/3 * jan-aug/2 */2'

Hash Operator (#)

The hash operator is used to schedule a task on the nth occurrence of a day of the week within a given month.

'0 0 * * 1#3' // At midnight the 3rd Monday of every month
'* * * 11 thu#4' // The 4th Thursday of November

Scheduling Tasks

Once you understand cron syntax, you are able to schedule tasks to run within your Node.js application. Install the package using NPM.
npm install node-cron
Import cron into the file.

const cron = require('node-cron');
// OR
import cron from 'node-cron';

Once you've installed and imported cron into your project use the schedule method to schedule the interval on which a task should run.
The schedule method takes two arguments, and an optional third argument: the cron expression string, and the function to execute. This example will execute a function to log 'Hello' to the console every 10 minutes.

import cron from 'node-cron';
cron.schedule('*/10 * * * *', () => {
   console.log('Hello');
}

Options Paramter

The schedule method also accepts an options object. This parameter can set if the task is scheduled or not, and also tell node-cron what timezone to use to schedule tasks.

scheduled: boolean to set if the created task is scheduled. Defaults to true
timezone: string of the timezone to schedule tasks. See IANA Timezone Database for possible values

Task Methods

If you set a task equal to the invocation of the schedule method, you are able to use methods of that task.

const task = cron.schedule('* * * * *', taskFunction);

task.start() starts the scheduled task
task.stop() stops the scheduled task (must be restarted to run)
task.validate(cronExpression) validates a given cron expression

Scheduling Tasks

In order for the application to run tasks, the server must read the file that the tasks are defined in. This means to import (or require) your task file in your server file. Alternatively, you could define your tasks directly on your server's app.js or index.js file. It is generally considered good practice to separate your tasks into a different file. This allows for better organization and maintainability.

Conclusion

node-cron provides a way for scheduling tasks within Node.js applications. By understanding cron syntax and utilizing the available options, you can improve efficiency, and save valuable time.

Sources

node-cron npm
node-cron docs

Node's GoogleGenerativeAI: Incorporating AI Technology In javaScript

Evan Loria — Sun, 26 Jan 2025 18:18:04 +0000

Introduction

The world has seen a lot of advancements in the AI world over the last several years. With artificial intelligence becoming more commonplace, developers must find ways to incorporate AI into their applications. Gemini offers an easy way for javasScript developers to build with AI through node's GoogleGenerativeAI package. Developers can access Gemini models, which are developed by Google's DeepMind, in order to create exciting features using AI. Other packages are available for those using Python or GO, and Gemini also has a RESTful API. This article will talk about the improvements Gemini's newest models bring to the table, and how to get started with the GoogleGenerativeAI package using node.

Major Developments

A major development the Gemini 1.5 Flash model brings is the amount of context tokens that can be handled in a single request. In the past, these types of models were limited by the amount of text, or tokens, that could be processed at a time. The generative models that have been created over the last few years only had the ability to process 8,000 tokens at once. While this number had improved with the advancements in AI technology, it still remained a limiting factor. Today, Gemini 1.5 Flash is capable of processing up to 1 million tokens at a time. The pro version (Gemini 1.5 Pro) can process up to 2 million. This makes Gemini capable of processing large amounts of information at once, while still maintaining a very high accuracy rate. You can read more about Gemini's advancements in AI world and what they mean here.

Getting Started

The first thing you will need to do in order to use the GoogleGenerativeAI package is crate a Gemini API key.
This is a quick and painless process.

Go to Google AI Studio
Click the 'Get API Key' button at the top left
Click the 'Create API Key' button

Once you've accessed an API key you'll need to install the package with node.
npm install @google/generative-ai
Once you've done all this you're ready to start developing with AI!

Setup

Import the package into the file you wish to use it.

import { GoogleGenerativeAI } from '@google/generative-ai'
// OR
const { GoogleGenerativeAI } = require('@google/generative-ai');

Create an instance of GoogleGenerativeAI while passing in your API key.

const genAI = new GoogleGenerativeAI('YOUR_API_KEY');

Use the getGenerativeAI method and pass in and object for the model you want to use. There are a number of models available, this example uses the Gemini 1.5 Flash model. Gemini Models

const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });

Once the model is setup, you can use the AI to generate text, respond to images, extract information from videos, and more.

Configuration and System Instructions

You can optionally provide the model with a configuration and system instructions. The configuration is applied on a generationConfig property within the generateContent method invocation. Some configuration options include:

responseSchema: Output schema of the generated text
candidateCount: (integer) Number of responses to return
temperature: (number) Controls the randomness of the output

See more generationConfig properties here.
Providing system instructions can help improve the response by providing additional context to the AI. In addition, the model will generate more custom responses, and be able to better suit the user's needs. The system instructions are provided when the model is initialized.

const model = genAI.getGenerativeModel({
  model: 'gemini-1.5-flash',
  systemInstruction: 'You are extremely friendly, always use your manners.',
});

Text Generation

Text can be generated in a number of ways using the package. The simplest way is to only provide the model with text, but there are more exciting and complex ways text can be generated. You can provide the model with an image along with the text in order to have the AI react to an image. Here is a simple example of a request that generates a response using only text.
The model setup is not included in this code block, but it is still part of the code.

const prompt = 'Tell me something about the moon';
const result = await model.generateContent(prompt);
let text = result.response.text();
// Log the response 
 console.log(text);

A prompt string is passed into the model's generateContent method. Once the response is returned, the response can be accessed on the response properties text method. The result of this response was: 'The Moon's surface is covered in a layer of fine dust called regolith, formed by billions of years of micrometeorite impacts. This dust is incredibly fine and clings to everything, posing challenges for astronauts and lunar equipment.' Pretty cool huh? This is a super simple example, but there are more possibilities.

Text Streaming and Chatting

The model waits for the entire response text to be generated before returning the response. Obviously right? If you didn't want to wait on the entire response to be generated, you can use text streaming to receive a faster response by not waiting on the entire result. This can be achieved using the streamGenerateContent method.
Here is an example from the Gemini API docs.

import { GoogleGenerativeAI } from '@google/generative-ai';

const genAI = new GoogleGenerativeAI('GEMINI_API_KEY');
const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });
const prompt = 'Explain how AI works';
const result = await model.generateContentStream(prompt);

for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  process.stdout.write(chunkText);
}

The package also offers the capability for keeping track of conversation. This helps users solve multistep problems by 'allowing users to step incrementally toward answers.' This is a relatively advanced feature of the Gemini API. More can be read about creating a chat and other text generation capabilities on the Gemini API Docs.

Conclusion

The GoogleGenerativeAi package makes it easy for javaScript developers to incorporate AI technologies into their applications. The package has numerous capabilities in AI generation, including text, video, and images. Gemini's ability to process a large amount of text at a time is a huge development in AI generation. With node's GoogleGenerativeAI, developers are able to include advanced AI technologies in their projects in a much easier way.

Sources

NPM
DeepMind
Gemini Long Context

Material UI: React Component Library

Evan Loria — Mon, 13 Jan 2025 05:32:46 +0000

Introduction

Material UI, or MUI, is an open source React component library used for building and designing user interface. MUI allows applications to be built quickly by offering out-of-the-box components. The library allows developers to provide a custom theme for their application, as well as customization options for individual components. This article will show how to create a custom theme, import components for use, and demonstrate the use of the stack component.

Installation

Material UI can be installed using npm or yarn. React and react-dom are peer-dependencies, so you must install these packages as well in order to use MUI.

npm install @mui/material
yarn add @mui/material

Components

Once MUI is installed along with its peer dependencies, the components can be imported and used to build your application. Import the component at the top of the file you want to use it. The below code block shows how to import the Button, Dialog, and List component.

import Button from '@mui/material/Button';
import Dialog from '@mui/material/Dialog';
import List from '@mui/material/Button';

Components can also be imported using destructuring.

import { Button, Dialog, List } from '@mui/material';

Once the component is imported it's available to be used as is.

<Button />
<Dialog />
<List />

Customization

MUI offers properties for each component that can be used for customization. Properties for each component are available on the MUI docs under the Component API tab.
Material UI Docs
Properties are assigned inside of the opening tag of the component. Here's an example of assigning property values when working with the button component.

<Button variant="text" color="black">Button</Button>
<Button variant="contained" size="large">Button</Button>
<Button variant="outlined" disabled>Button</Button>

All components have an sx property available to them, which is used to for system overrides as well as other CSS styles that are not direct properties of a component.

<Button
  variant="contained"
  sx={{ 
  backgroundColor: 'purple',
  width: 200,
  color: 'white',
 }}
>Button
</Button>

Themes

MUI offers the ability for users to create custom themes. This feature enables users to maintain consistency between like components across the application, as well as the ability to create a custom color palette. Import the createTheme function and ThemeProvider component.

import { createTheme,                         
         ThemeProvider                                    
       } from '@mui/material/styles';

The createTheme function accepts an object argument, with the properties equal to the element for the styles to be applied to. Set a variable equal to the invocation of the createTheme component on your custom theme object.

const theme = createTheme({
components: {
 MuiButton: {
  styleOverrides: {
   root: {
    width: 100,
    backgroundColor: 'blue'
    }
   }
  }
 }
});

The components property is used to define which MUI component will be effected by the styles. The styleOverrides property is used to override the styles of components. In this case, we are overriding the styles of Button root components. Once you are happy with the theme you have created, you need to wrap the component you want the theme to apply to in the ThemeProvider tag, and supply the theme variable name to the theme property.

<ThemeProvider theme={theme}>
 <YourComponent /> 
<ThemProvider />

We can also use CSS classes of components to define style overrides. The classes for each component exist on the components API within the MUI docs. We can put a '&.Mui-disabled' (must be in quotes) property on our root property object to define the styles of any disabled Button component.
This is just one way to define styles for components. I recommend looking into the documentation for custom themes on the Material UI docs, as well as the docs on creating custom palettes.
Themes
Palette

Containers

Lastly, MUI offers different containers for grouping components to be displayed on the page. One of those components is Stack, which can be used to group elements vertically or horizontally.

import { Stack } from '@mui/material';
      <Stack spacing={6}>
        <Item>One</Item>
        <Item>Two</Item>
        <Item>Three</Item>
      </Stack>

The spacing property determines how far apart the elements will be from each other. The default direction of the stack is vertical. To stack the elements in a row, set the direction property equal to "row".

import { Stack } from '@mui/material';
      <Stack direction="row" spacing={3}>
        <Item>One</Item>
        <Item>Two</Item>
        <Item>Three</Item>
      </Stack>

For more complex, two-dimensional designs, MUI offers the Grid component. You can read the documentation here.

Conclusion

Material UI emphasizes speed and efficiency in enabling developers to build and customize web applications. Their are many more, ready-to-use, well-documented components and customization options available to developers using Material UI. This article only scratches the surface of what Material UI has to offer.

Sources:
Material UI Documentation
MUI Button
MUI Themes
MUI Stack

Internet of Things: The Benefits and Challenges of Connected Devices

Evan Loria — Mon, 02 Dec 2024 07:30:59 +0000

Introduction

Internet of Things (IoT) is a network of devices that are connected to each other via the internet, and the technology that allows these devices to communicate with each other. These devices automate our lives, and reduce the need for human intervention in certain tasks. These devices contain technology that can collect, send, and receive data. IoT networks provide a number of benefits to our everyday lives, but they also introduce challenges due to the amount of interconnected devices and data points within a network.

IoT Devices

An IoT device a device that is connected to the internet, and has the ability to exchange 'data with other devices or systems.'(What is an IoT Device) These devices use sensors to collect information, which can then be sent to an IoT platform. Once the data is analyzed by the platform, the necessary actions can be triggered to indicate that a task needs to be done, or something was detected within a device.

IoT Platform

IoT devices use sensors to collect data about the device itself, or the environment of a device. These sensors are continuously transmitting data to applications known as IoT platforms. An IoT platform is the core of a network. A platform allows the devices of a network to communicate, send data, and receive commands. The type of platform a network wants to use depends on the the purpose, or functionality, of the devices of a network. You can read more about IoT platforms and the different types here.

IoT Steps

Data is collected by the sensors within a device
Information is sent to the IoT platform
Platform transforms the data so that it can be analyzed
Data is analyzed using algorithms
Actions can be triggered if necessary based on the analysis of the data received. ## IoT Benefits IoT networks have the ability to make our lives simpler. These networks offer a number of benefits to us everyday, such as:
Easy Accessibility: Because IoT networks store all the data in a central location, any device connected to the network is able to access any data that was produced by another device on the network.
Improved Communication: Data is stored in a structured way within a network, which allows information to be received more quickly.
Saving Time and Money: By providing real-time analysis, networks are able to catch problems as they occur. This eliminates the need for human-intervention when detecting issues, and can ultimately save money by catching issues early on.
Process Automation: IoT networks reduce the need for human-intervention in certain tasks.

Some other benefits of IoT networks are:

Better Business Decisions
Productive Analysis
Labor Reduction
Performance Monitoring

Challenges

The use of IoT networks has a number of upsides in many aspects of our lives, however, the existence of these large networks do not come without a few challenges.

Security

As a the number of devices within a network grows, so does the risk of a cyber attack. Because of the number of devices and amount of data within a network, the attack surface of a network can become extremely large. An attacker can access information through a handful of different entry points.
It is important for these networks to remain secure because of the amount of information they hold.

Data Management

The shear volume of data within a network can be complex to manage. An IoT network deals with a large amount of data, coming from a number of different devices. A single network can be dealing with any number of different data types. This is a big reason why data needs to be efficiently stored.

Mass Corruption

While it is beneficial for data to be stored in a central location for all devices to access, it also introduces the risk of mass corruption on a network. If a bug is introduced to a network device, it could wind up affecting every device within the network.

Compatibility

Devices from different manufacturers can exist on the same network. Because there is not a standard for IoT compatibility, there is a possibility some devices are not compatible with each other.

Job Displacement

Because IoT networks remove the need for human-intervention by automating tasks, some jobs can be replaced by devices. This is especially true for lower-skilled jobs.

IoT Examples In Different Fields

IoT devices are used across every type of field throughout the world. Networks are able to offer different kinds of benefits depending on the purpose of the devices.

Healthcare

A heart monitor that is able to relay information about a patient's heart. The data received from this device could be used to detect a heart attack or other heart diseases.

Manufacturing

A machine with a sensor that collects data about the environment within the machine. The data collected by the sensor could determine if a machine is working properly, or if it is due for maintenance. This could be a huge factor in saving a company time and money.

Agriculture

An irrigation system that can be automated to water plants under certain conditions. A device could detect the moisture of the soil and trigger the water to be sent at a certain level. Also, a user could tell water to be sent at different intervals with minimal intervention.

Conclusion

IoT is a network of devices connected by the internet which have the ability to collect, send, and receive data. These interconnected devices automate our lives, offering many benefits, as well as introducing challenges in order to protect information, and efficiently manage data. IoT will continue to become more advanced in the coming years with the advancements in machine learning.

Sources

Amazon Web Services
IBM
CloudFlare
TechTarget
cbtNuggets
BuiltIn
SoftwareAg

Intro to Brain.js, Creating Neural Networks in javaScript

Evan Loria — Mon, 18 Nov 2024 07:50:49 +0000

Introduction

Brain.js is a javaScript library that is used to create neural networks using javaScript. The Brain.js library makes it easier to understand neural networks by supplying methods that hide all the complex computations that are done inside of a network. I will talk more specifically about what a neural network is, the methods Brain supplies, and how the library simplifies the process of creating a neural network.

Neural Network

A neural network is a machine learning algorithm that uses a series of connected nodes in order to process data and makes decisions. This type of algorithm is inspired by how the human brain makes decisions using neurons that fire information to each other. Networks have three different types of layers, which contain nodes that pass information to and from each other. Functions are run on the input passed into nodes in order to determine whether or not a node should continue to pass along the information it received. You can find a more in depth explanation of neural networks and their nodes here.

Brain.js

Brain.js makes it possible to create neural networks using javaScript, and helps users to understand how neural networks work in the process. The library can be installed using npm.
npm install Brain.js
Once installed, a neural network can be created in the same way a new javaScript class is created: Snippet from Brain.js Documentation

const network = new brain.NeuralNetwork(options)

brain.NeuralNetwork takes in an optional hash table, which tells the network how to behave.
A few optional properties to supply the network:

inputSize: The number of input nodes
outputSize: The number of output nodes
learningRate: Controls the step size during training iterations: The max number of training sessions in a network
activation: The activation function used in network training. Activation Functions
hiddenLayers: An array of numbers that specifies the number of hidden layers, and number of nodes on each layer.

const options = {
inputSize: 4,
outputSize: 4,
learningRate: 0.3
activationFunction: 'sigmoid',
hiddenLayers: [3, 4]
}

The properties have default values if they are not defined.

Training a Network

Networks have a train() method to train a network what an output should be when given a certain input. train() takes in an array of data for the network to learn from. Each training pattern in the array has an input and an output property. Input and output can be either an array of numbers 0 through 1, or a hash table of numbers 0 through 1.
Let's look at an example from W3 Schools that trains a network to output either 1 or 0 based on an input array.

const network = new brain.NeuralNetwork(options);
network.train([
  {input: [0,0], output: [0] },
  {input: [0,1], output: [1] },
  {input: [1,0], output: [1] },
  {input: [1,1], output: [0] }
])

The input property tells the network what is being supplied. The output property tells the network what the output should be when given the corresponding input.
The output of train() is a hash table containing information of how the training went.

// W3 Schools Example
{
  error: 0.0039139985510105032,  // training error
  iterations: 406       // training iterations
}

Brain.js run()

Once a network is trained, the run() method can be used to output a networks prediction when a certain value is passed in. Using the same trained network from above, we can pass in an array to the run method, and the array will output its prediction based on what it learned during the training. The return value of run() is a hash table with properties that correspond to the possible outputs. The values of these properties are a number that represent how likely it is that that property is the output that should be supplied with the current input.

// W3 Schools Example
let result = network.run([1,0]); 
/* result will be: 
{"zero":0.06577067077159882,"one":0.9343253374099731}
*/

The network tells us that there is a 93% chance that the output of the input [1,0] is 1. We are also able to use object property access on the result just like we would with a normal javaScript object.

// W3 Schools Example
console.log(result["zero"]; // 0.06577067077159882
console.log(result["one"]; // 0.9343253374099731

Other NeuralNetwork Methods

network.forecast(input, count)

Returns an array of predictions for the input. Count is how many predictions are given.

network.toJSON()

Returns the network converted into JSON format.The network can then be saved to a file or moved into a database.

network.fromJSON()

Unstringifies a network so that it can be used for predictions.

Additional Information

This blog only mentions the very basic capabilities of the Brain.js library. Brain.js is capable of creating different types of neural networks (RNNTimeStep, LSMTimestep, GRUTimeout) which have unique behaviors. The library also allows a network to be trained asynchronously with certain network types by using trainAsync() in place of train(). If you find this post interesting, I encourage you to look at the Brain.js documentation, provided in the sources below, to get a deeper understanding of the library's capabilities.

Conclusion

Brain.js simplifies the complex topic of neural networks and machine learning. Networks are able to be created using the 'new' keyword, and then can be interacted with using methods supplied by the library. By hiding all the complexities of neural networks behind the scenes, a user can more easily understand how the complex algorithms work.

Sources:

Brain.js Documentation
Medium
W3 Schools

Promises: The Ability to Write Asynchronous Code Using Javascript

Evan Loria — Mon, 11 Nov 2024 10:05:18 +0000

Introduction

By nature, Javascript is a synchronous, single-threaded programming language. This means that operations are run one at a time, in the order they were called. Web applications need the ability to perform multiple operations at the same time. Using synchronous code, a program would have to wait for an operation to complete before the program could continue running. For this reason, Javascript offers a way for developers to create asynchronous operations that perform in the background, allowing code to continue running before an operation is completed.

Asynchronous Callbacks

A callback is a function that is passed into another function to be called at the appropriate time. Before the introduction of promises in Javascript ES6, callbacks were used to handle asynchronous operations. Because Javascript uses an event loop to track the order in which functions should be executed, functions are able to execute in a different order in which they were called.

const addOne = function(number) {
  number += 1;
  return number;
};
const addNextNumber = function (number, addOne) {
  return number + addOne(number);
}
addNextNumber(5);

The addNextNumber function relies on the return of the addOne function. The addOne function finishes executing, and then the addNextNumber function is able to complete its operation.

However, if we need to pass multiple callbacks into one another our code can become difficult to understand. When callbacks become overly nested it is called callback hell, or the pyramid of doom.

Example From MDN:

function doStep1(init, callback) {
  const result = init + 1;
  callback(result);
}
function doStep2(init, callback) {
  const result = init + 2;
  callback(result);
}
function doStep3(init, callback) {
  const result = init + 3;
  callback(result);
}
function doOperation() {
  doStep1(0, (result1) => {
    doStep2(result1, (result2) => {
      doStep3(result2, (result3) => {
        console.log(`result: ${result3}`);
      });
    });
  });
}
doOperation();

You can see how nesting callbacks can become difficult to read when callback functions take in another callback. Especially when dealing with more complicated callbacks that fetch data from a server.

Promises

A promise is a unique object that is returned by an asynchronous function that represents the eventual success or failure of an asynchronous operation. Promises are the foundation of asynchronous Javascript. Promise objects contain two properties: state and result:

State Property Value Options

Pending: The function that created the promise has not finished executing
Fulfilled: The asynchronous function succeeded
Rejected: The asynchronous function failed

Result Property Value Options

The value of the successful result
The value of the failed result
Undefined

It is worth noting that the above properties are not code-accessible. We can only view them using a debugger tool.

The Fetch API is what javascript uses to make requests to a server. It replaced XMLHttpRequest, which uses callbacks. A request is made by calling fetch(), which can take in an object, or a string url of a resource to send a request to. The return value of fetch() is a promise object.

Promise Handlers

The promise object supplies methods to deal with the result of a promise. We will be talking about the .then() and .catch() handlers, but you can find other promise handlers here.

.then() Handler

.then() takes in two callback arguments: one for the case of a fulfilled promise, and one for the rejected promise. This handler is capable of returning a promise, returning a value, or throwing an error.
Let's set a variable equal to the promise returned by invoking fetch()

const ourPromise = fetch("https://example.com/post");

We can attach then() to our promise, and once the promise is fulfilled or rejected it will perform the corresponding callback argument.

const fulfilledCB = function() {
console.log('Promise was successful');
};
const rejectedCB = function() {
console.log('Promise failed');
};
ourPromise.then(fulfilledCB, rejectedCB);

If our promise is returned successfully, our fulfilledCB will run. If the promise was rejected, then our rejectedCB will run. We can optionally only pass in a callback for the value we are interested in, setting the unwanted value's callback to null.

Chaining Promises

Once a response object is received using fetch(), we need to use another function to access the data of the response. We can do this using the json() method to transform our promise into a json object.

const ourPromise = fetch("https://example.com/post");
ourPromise.then((response) => {
return response.json();
}).then((user) => {
console.log(user.name)
});

We use our first .then() to transform the promise into json, and the second to access the data within our response object.

.catch()Handler

You may have noticed that in the above code snippet we did not provide a callback to handle rejected promises. When using promise chaining, we attach the .catch handler to the end of our chain. This handler will take in a callback to deal with any promise that was rejected at any point in the chain. .catch() can also be used with only one .then() rather than passing in an error callback to .then().

const ourPromise = fetch("https://example.com/post");
ourPromise.then((response) => {
return response.json();
}).then((user) => {
console.log(user.name)
}).catch(() => {
console.log('One of your promises was rejected');
};

.catch() offers an extremely simple way to handle errors when dealing with asynchronous code.

Conclusion

In order for our programs to run as efficiently as possible, it is imperative that our code have the ability to run asynchronously. Long-running synchronous code would cause a program to become unresponsive while it waited on the return of an operation. Promises offer an elegant solution to writing asynchronous code by improving code readability, simplifying error handling, and allowing developers to avoid callback hell.

Sources:

MDN Promises
MDN Introduction to Asynchronous Code
Free Code Camp Asynchronous Javascript
Green Roots Promises Explained Like I Am Five
Green Roots Handling Promises
Dev Community Callbacks, Promises, and Async/Wait

Dynamic Link Library Basics

Evan Loria — Mon, 07 Oct 2024 13:53:18 +0000

What are Dynamic Link Libraries

Dynamic Link Libraries (DLLs) were created by Microsoft, and are usually written using C++. A dynamic link library is a type of file that allows resources, such as functions and other types of data, to be shared across multiple applications. They offer a number of benefits to Microsoft’s programs, but they can also induce errors within programs.

What They Do

DLLs offer multiple benefits for Microsoft’s applications to run. DLLs reduce the size of files, which in turn improves the performance of the program. Because several programs are able to use a DLL at the same time, the same block of code is able to be used by multiple programs.

In addition, the DLL code is able to be updated independently from the other programs, and the programs will have access to the updated code. This is much easier than having to update code in each individual program.

However, there are dangers to be aware of when using DLLs across multiple programs. Updates can cause a program's code to break due to compatibility issues. DLLs can also leave systems vulnerable to malware attacks.

Static Library

'Static libraries refer to a set of routines, external functions, and variables compiled and linked into an executable file at compile time.' (Vijay Kanade, What Is a Dynamic Link Library (DLL)? Meaning, Types, and Advantages) These types of libraries cause files to become larger because it appears as if the library code is part of the program itself. These libraries are more beneficial when creating a smaller library, and they are able to cut down the time is takes to execute a function.

Dynamic Library Differences

Unlike static libraries, dynamic libraries are only loaded to memory at the execution of a function within the library. The DLL is referenced within the memory of a computer when a program is started. Once the program requests the use of a function, then the library is loaded into memory. This library is better served when creating larger files and programs.

Steps For DLL

When a program needs a function: The program searches for the DLL in memory. If it is not found, then the library is loaded into memory, and the resources added to the memory space of the program.
Link to DLL: A function is called to link the DLL to the program. A dynamic link method is then used to link the library and the program. A dynamic link being used means that only a portion of the DLL file will be loaded into the program memory. This reduces file size, but increases the time it takes to run the program.
Once the first two steps are completed the program has access to all the resources within the DLL.
The DLL is offloaded from the computer's memory once the program has finished using it.

Advantages

Code Reuse: Dynamic libraries enable programs to reuse code. This eliminates duplicate code, enabling programs with matching functionality to use the same block of code.
Better Performance: Because DLL's control the size of files, and only load the DLL into memory when needed, the program can better execute due to the reduced loading time.
Encourages Modularity: Modularity is beneficial to creating programs because it allows component's to focus on smaller tasks. DLLs encourage modularity by allowing each component full access to the resources within.

Conclusion

DLLs offer many benefits to programs and operating systems in general. These libraries play a huge role in the overall performance of a computer’s programs. Although the use of DLLs is not a perfect way to enhance a program's efficiency, by limiting file size, encouraging modularity, and eliminating duplicate code DLLs allow for more efficient program execution.

Sources

Learn Microsoft
Medium
Spice Works

Neural Networks

Evan Loria — Mon, 30 Sep 2024 12:38:00 +0000

Introduction

Machine learning is the process in which artificial intelligence uses data and algorithms to learn over time. Models are able to run multiple simulations, changing how much weight a particular variable holds on a decision, and then compares the result to the expected result. Neural networks are a subclass of machine learning. Rather than making decisions based on the data the system receives, neural networks are able to create new variables to factor into their decision making. This gives neural networks the ability to attempt to give answers to more complex problems.

Basic Structure

Neural networks are designed to make decisions like the human brain. They use nodes/neurons that pass information to each other at different intensities, and then decide whether or not to discard that information. These networks are made up of layers that consist of nodes that pass data to each other. The strength of the connection between two nodes is called the connection weight. This will determine how much impact the data coming from a node will have on the decision of the node receiving the information. Larger 'weights' have more of an impact on a node's decision making. Weights are initially randomly assigned, but will changed overtime as the system learns which data is more important.

Input Layer

First, the data is passed into the nodes/neurons within the input layer. "Each neuron corresponds to a feature, and its value represents the feature’s value" (Sarita, 'Basic Understanding of Neural Network Structure'). Each node then passes the weighted sum value to every node on the next layer.

Hidden Layer

The hidden layer is the the next layer within the network which receives the weighted sum from the input layer. The weighted sum is calculated by multiplying the output of the node by the connection weight between the two nodes exchanging data, and then adding all the resulting values together.

In the example below, the weighted sum is calculated by:
Value1 = 160 Weight1 = 0.35 Value2 = 55 Weight2 = 0.2 (Value1 * Weight1) + (Value2 * Weight2) = 67

Deep Learning Dictionary - Lightweight Crash Course

The bias of the node will then be added to the weighted sum before being passed into an activator function. The bias is a constant that "is used to offset the result. It helps the models to shift the activation function towards the positive or negative side."(Turing, 'What Is the Necessity of Bias in Neural Networks?)
The value of bias will change as the system learns

A network may have multiple hidden layers depending on how complex it is. In these cases, each hidden layer is in charge of learning about a separate aspect of the data. The layers are broken up into components that perform smaller tasks.

Activator Functions

Activator functions are required to make networks non-linear, allowing data to be passed in all directions to different nodes, and then backwards through the network. The purpose of an activator function is to tell a node whether or not to send data to the next layer (activate). Different activators will perform different transformations on node output, and have different return values. If the activator function does not tell the node to fire, then it will not output any information to the next layer.
A few popular functions are:

Sigmoid
TanH
ReLu

Output Layer

The final hidden layer passes data to the output layer, which is where the final decision/output of the model will be made. The same calculations performed within the hidden layers are also performed here. The weighted sum is calculated and the bias is added. That number is then passed into an activator function that tells the node whether or not to fire.

Backward Propagation

This is where the model is able to learn from the mistakes it made. The data is passed backwards through the system, and evaluated to see where mistakes were made. The system changes the weights and biases over the nodes, and runs the simulation again. By changing the weights, the system is able to learn which variables are more impactful when making a decision.

Summary

Neural networks are complex machines, with the ability to analyze data, compare results, and manipulate conditions in order to become better decision makers. The system is composed of three types of layers, which are a collection of nodes that pass data to each other. The hidden and output layers perform calculations that decide whether or not information should continue to be passed through the network. A huge characteristic of these networks is the ability to pass data backwards, which gives it the ability to learn and improve.

Sources:
AWS Neural Network
IBM Neural Network
Basic Understanding
AI, Machine Learning, Neural Networks, and Deep Learning
Function Activation

Malware: Detection, Collection, and Analysis

Evan Loria — Mon, 23 Sep 2024 11:45:47 +0000

What is Malware

Malicious software, or malware, is software that is specifically designed to disrupt, damage, or gain unauthorized access to a computer system. The existence of malware requires users and companies to secure their systems, in order to prevent data leaks. Researchers are constantly working with live malware and analyzing behavior in order to develop new techniques in combatting attacks.

Malware Classification

A user can become infiltrated by malware in a number of different ways. Attackers will use different methods to trick a user into downloading different types of malware. Malware is often disguised as a regular link or file, and will be downloaded when a user clicks on the element. It is even possible for a user to become infected without clicking on anything if they visit an infected website. Common types of malware include:

Worms: Software that spreads through a network by replicating itself
Trojans: Software that disguises itself as desirable code
Spyware: Software that secretly collects user activity
Adware: Software that displays unwanted ads
Ransomware: Software that locks a user out of their environment until a ransom is paid

Detection and Collection of Malware

The ability to detect malware within a network or server is a key skill in protecting user data. If a server has been compromised, the software will leave signs of its presence, these signs are known as indicators of compromise(IOCs). Some IOCs include unusual traffic, an increase in the number of incorrect logins, or files existing in the incorrect locations.

One technique to detect attacks is a malware honeypot. Honeypots are designed to look like a regular application, and invite attacks onto the system in a secure environment that does not actually allow access to the server. This allows for the detection of malware because the honeypot is hidden, so any traffic on the honeypot is likely malicious.

Malware Analysis

Malware can be analyzed statically, without running the code, by looking at the name of a file, the address the file came from, and other signs a file may be malicious.

On the other hand, dynamic analysis views the software while it is running. Honeypots are a great dynamic analysis tool. If a hacker commits an attack on a honeypot, their activity is able to monitored, this can be used to learn valuable information on what type of attack is being attempted, and the best way to respond.

Another technique used for data analysis is sandboxing. Sandboxing refers to the practice of downloading malware into a totally separate environment from the server, where the malware's behavior can be studied. "Security researchers use sandboxing when analyzing malware and many advanced anti-malware products use it to determine whether or not suspicious files are truly malicious based on their behavior." (Marc Laliberte, The Difference Between Sandboxing, Honeypots & Security Deception)

Malware Data Sets

There are databases available that contain samples of known types of malware and their features. The existence of these datasets offer the ability to test methods to detect malware. Some reputable malware repositories include theZoo, InQuest, and malwareBizaar.

Why It's Important

The detection and analysis of malware within a system is pivotal to protecting user data. It's believed that there are "more than 1 billion malware programs" in existence, with thousands more created each day.(Darren Craft, Malware Statistics & Facts: Frequency, Impact & Cost) With the constant development of new malware, researchers must also develop new ways to detect, analyze, and prevent malware attacks.

Sources:
Malware Classification
Types of Malware
Malware Detection Techniques
Indicators of Compromise
Honeypots
Malware Analysis
Honeypots & Sandboxes

Why We Need Higher-Order Functions

Evan Loria — Fri, 09 Aug 2024 17:30:03 +0000

What is a Higher Order Function?

Higher Order Functions are functions that are able to take in a function as an argument, or return a function. These characteristics allow developers to produce the desired result in a much more readable way. This article will give some examples of well known higher-order functions and the benefits they provide.

Functions as Arguments & Return Values

The ability to pass a function as an argument, or return a function call is a huge benefit to developers. This is a key way to make code more neat and readable. As Joan Ayebola put it in her article 'What are Higher Order Functions in JavaScript? Explained With Examples' It also allows for 'dynamic behavior' within our code.

// Function as an argument

When the higher order function is called:

The function performs its code (in this case it's logging to the console)
The callback function is invoked and performs its tasks
Expect 'DO SOMETHING' and 'I was passed as an argument' to log to the console

// Function as a return value

When greet_message is called:

The function calls the greet function with 'Evan' passed in
greet() returns a function that logs a greeting to the console
Expect 'Hi!! Evan, Welcome To Operation Spark!' to log to the console

Useful Higher-Order Functions

.filter() Method
.map() Method
.forEach() Method
.reduce() Method

Each of these is an array method that takes a function as an argument.

.filter()

Iterates over an array and returns a new array of all the elements that returned a truthy value when passed through the function argument. Does not mutate the elements. The .filter() method takes in a parameter representing the current element being passed over.

.map()

Iterates over an array and returns a new array of the result of invoking the function argument onto each element in the array. The .map() method takes in a parameter representing the current element being passed over.

.reduce() Method

.reduce() can be used in many different ways. It iterates over an array and returns a single value. The function argument of .reduce() takes in 2 parameters:

accumulator: The value to be returned at the end of the function call
current: The current index being passed into the function

.reduce() also has an optional third parameter seed. Seed defines the value in which accumulator will start at. If no seed is given, the accumulator value begins at the first element of the array, and the function begins iterating at the second element.

Other possible uses for .reduce()

Set the seed as an empty array and push desired elements onto it
Assign key-value pairs to an object
Concatenate to a string

.forEach()

Iterates over an array and mutates each element. A key charatceristic to note about the .forEach() method is that it has no return value. Therefore, unlike the other 3 methods, you cannot initialize a variable to the value of invoking .forEach(), because the return value is undefined. Just like .map() and .filter(), .forEach() takes a parameter representing the current element being passed over.

Conclusion

While higher-order functions may be a little confusing at first, they really make developers lives a lot simpler. Without the ability to return functions, or pass in functions as arguments; our code would become a lot less readable very quickly.

TIP

It may be a good idea to look at the native code for all of these methods. The more you understand about how these functions work, the easier they will be.

Source: https://www.freecodecamp.org/news/higher-order-functions-explained/#:~:text=JavaScript%20offers%20a%20powerful%20feature,even%20return%20functions%20as%20results.