DEV Community: Alexej Bondarenko

Capitalizing the First Letter in JavaScript

Alexej Bondarenko — Sat, 06 Jan 2024 08:29:49 +0000

JavaScript is a versatile language, essential for creating dynamic and interactive web applications. One common task that developers often encounter is manipulating strings, particularly capitalizing the first letter. This seemingly simple task is crucial in enhancing the readability of text, adhering to grammatical rules, and improving user interfaces. In this article, we'll explore various methods to capitalize the first letter of a string in JavaScript, discussing their advantages and suitable scenarios.
Understanding the Basics:

Before delving into the solutions, let's understand what a string is in the context of JavaScript. A string is a sequence of characters used to represent text. In JavaScript, strings are immutable, meaning once created, they cannot be changed. However, you can create new strings based on operations performed on the original ones.

Method 1: Using charAt() and slice()

One of the simplest ways to capitalize the first letter is by using the charAt() and slice() methods.


function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

How it works:

charAt(0): This method returns the first character of the string.

toUpperCase(): Converts the character to uppercase.

slice(1): This method slices the string from the second character to the end.

Pros:
Easy to understand and implement.
Efficient for short strings.

Cons:
Not the most concise method.

Method 2: Using Regular Expressions

For those comfortable with regular expressions, this method offers a concise way to capitalize the first letter.


function capitalizeFirstLetter(string) {
    return string.replace(/^./, string[0].toUpperCase());
}

How it works:

replace(): This method replaces the first character (matched by the regular expression ^.) with its uppercase version.

Pros:

Concise and elegant.
Powerful in handling more complex patterns.

Cons:

-Less readable for those not familiar with regular expressions.

Method 3: Using ES6 Features

If you're working in an environment that supports ES6 features, template literals and destructuring can offer a clean solution.


const capitalizeFirstLetter = ([first, ...rest]) => first.toUpperCase() + rest.join('');

How it works:

Destructuring assignment is used to split the first character and the rest of the string.
Template literals then reconstruct the string with the capitalized first letter.

Pros:

Clean and modern syntax.
Expressive and concise.

Cons:

Only suitable for environments that support ES6.

Best Practices and Considerations:

Check for Empty Strings: Always check if the string is empty before attempting to capitalize it to avoid errors.

Locale Considerations: For applications supporting multiple languages, consider using toLocaleUpperCase() instead of toUpperCase() to respect locale-specific rules.

Performance: For applications dealing with large volumes of text, test the performance of your chosen method.

Summary

Capitalizing the first letter of a string in JavaScript is a common task that can be achieved through various methods. Whether you prefer the straightforward approach of combining charAt() and slice(), the elegance of regular expressions, or the modern syntax of ES6 features, there's a solution that fits your needs and coding style.

Understanding these methods not only helps in text manipulation tasks but also enhances your overall JavaScript proficiency. So, next time you're faced with a string manipulation challenge, you'll be well-equipped to handle it with grace and efficiency.

If you are interested in how other languages handle the same question, I have blogged about the same topic for PureScript in my article "Capitalizing the First Letter in PureScript".

Lists and LinkedLists in JavaScript

Alexej Bondarenko — Sat, 06 Jan 2024 08:12:51 +0000

Recently I was asked in an interview the question about Lists and LinkedLists in Java. After the interview I came up as well with the idea to see how other languages handle this.

In JavaScript, the concept of lists and linked lists is quite different from their implementation in Java, largely due to the nature of the languages themselves. The following are the differences and the underlying reasons:

1. Introduction

In the realm of programming, data structures are fundamental. Among these, lists and linked lists are crucial for storing and manipulating collections of data. While languages like Java have explicit classes for these structures, JavaScript's approach is more implicit, owing to its dynamic and flexible nature.

2. Lists in Java vs. JavaScript

In Java, a list is an interface, and it is part of Java's Collections Framework. It defines an ordered collection, and classes like ArrayList and LinkedList provide concrete implementations. These lists come with various methods for data manipulation, ensuring type safety and offering performance benefits for different use cases.

In contrast, JavaScript does not have a built-in list data structure. The closest equivalent is an array, which is a high-level, list-like object. JavaScript arrays are dynamic and can hold a mix of different data types. They provide methods similar to Java's lists, but without the type safety and with some differences in performance characteristics.

3. LinkedList in Java

In Java, LinkedList is a doubly-linked list implementation of the List and Deque interfaces. It allows for constant-time insertions and deletions at both ends and is efficient for manipulating data. However, it has slower random access compared to an ArrayList.

4. Linked Lists in JavaScript

JavaScript does not have a built-in linked list class. However, its dynamic nature allows for easy implementation of a linked list from scratch. A JavaScript linked list typically involves creating a Node class and a LinkedList class with methods for addition, deletion, and traversal.

5. Why the Difference?

The key reason for this difference lies in the language design philosophies:

Java: Java is statically typed and has a strong emphasis on explicitness and object-oriented design. The Collections Framework in Java provides a standardized way of handling data structures, ensuring type safety and predictability.

JavaScript: JavaScript is dynamically typed and prioritizes flexibility and ease of use. It does not enforce a strict data structure paradigm, allowing developers to implement structures like linked lists as needed, using the basic objects and arrays.

6. Practical Implications

For JavaScript developers, this means that understanding the underlying principles of data structures is essential. While JavaScript does not provide these structures out of the box, its flexibility allows for tailored implementations that can be optimized for specific use cases.

7. Summary

In conclusion, the absence of explicit list and linked list structures in JavaScript, as opposed to Java, is a reflection of the language's design and philosophy. JavaScript's dynamic arrays and the ability to implement custom data structures offer a different, more flexible approach to data management. Understanding these differences is crucial for developers transitioning between languages or working in multi-language environments.

How to Fetch the Bitcoin Price from Kraken API in PureScript

Alexej Bondarenko — Tue, 19 Dec 2023 09:39:10 +0000

In the fast-evolving world of cryptocurrencies, staying updated with real-time prices is crucial for both enthusiasts and investors. Bitcoin, being the pioneer and most valued cryptocurrency, holds significant interest. This article delves into how one can harness the capabilities of PureScript, a powerful and expressive functional programming language, to fetch Bitcoin prices from the Kraken API.

PureScript, often likened to Haskell, is a strongly-typed language that compiles to JavaScript. It's known for its robust type system and functional programming paradigms, making it an excellent choice for writing reliable, maintainable web applications. Its strong type system can enforce correctness at compile time, reducing runtime errors and enhancing code quality.

Kraken, on the other hand, is one of the largest and most respected cryptocurrency exchanges in the world. It offers a comprehensive API that provides access to real-time and historical market data, including Bitcoin prices. Utilizing this API, developers can integrate cryptocurrency data into their applications or perform analysis.

In this article, we will guide you through setting up a PureScript environment, understanding the basics of the Kraken API, and step by step, demonstrate how to write a PureScript application to fetch the current Bitcoin price. This journey will not only enhance your understanding of PureScript and APIs but also provide you with a practical tool for cryptocurrency data retrieval.

Whether you are a seasoned PureScript developer or new to the language, this guide aims to provide valuable insights and practical steps to effectively interact with the Kraken API. So, let's dive in and explore the intersection of functional programming and cryptocurrency data fetching.

Setting Up Your PureScript Environment

Getting started with PureScript requires setting up the appropriate development environment. This section will guide you through the installation of the PureScript compiler, Spago (the PureScript package manager and build tool), and the creation of a new PureScript project.
Installing PureScript
Prerequisites

Node.js: PureScript compiles to JavaScript, so Node.js is required to run the resulting code. Install the latest version of Node.js from nodejs.org.

Installation Steps

Install PureScript: Use npm (Node.js package manager) to install PureScript globally. Open your terminal or command prompt and run:

npm install -g purescript

Verify Installation: Ensure PureScript is installed correctly by checking its version:

purs --version

Installing Spago

Spago is a PureScript package manager and build tool, designed to work with the PureScript package set.
Installation Steps

Install Spago: Again, use npm to install Spago globally:

npm install -g spago

Verify Installation: Check if Spago is installed properly:

spago --version

Setting Up a New PureScript Project

Now that you have PureScript and Spago installed, you can set up a new PureScript project.
Creating the Project

Create a New Directory: Make a new directory for your project and navigate into it:

mkdir my-purescript-project
cd my-purescript-project

Initialize the Project: Use Spago to initialize a new PureScript project:

spago init

This command will create a new PureScript project in your current directory. It includes some basic files:

src/Main.purs: A sample PureScript source file.

test/Main.purs: A sample test file for your project.

spago.dhall: Configuration file for your project dependencies and build settings.

Exploring the Project

Take a moment to explore the structure of your new PureScript project. The src directory will hold your PureScript code, and test is for your test files. The spago.dhall file allows you to manage dependencies and specify project settings.
Next Steps

With your PureScript environment set up, you're ready to start writing PureScript code and explore its capabilities. The next section will introduce you to the Kraken API, which we will use to fetch Bitcoin prices.

Understanding the Kraken API

Before diving into coding, it's crucial to understand the Kraken API, which will be our gateway to fetching Bitcoin prices. This section will provide an overview of what the Kraken API offers, focusing on the specific endpoint we'll use for retrieving Bitcoin prices.

What is the Kraken API?

Kraken is a popular cryptocurrency exchange that provides a feature-rich API. This API allows developers to access market data, manage accounts, execute trades, and more. For our purpose, we are interested in the public market data that Kraken provides, specifically the current price of Bitcoin.
Key Features of the Kraken API

Public and Private Endpoints: The API offers both public and private endpoints. Public endpoints provide market data like asset prices, order book details, and recent trades.

Private endpoints, which require authentication, are for managing accounts and executing trades.

Rate Limits: Kraken imposes rate limits to ensure fair usage of their API. It’s important to be aware of these limits when designing your application to avoid being temporarily banned from the API.

Data Format: Responses from the Kraken API are typically in JSON format, making it easy to parse and use in your application.

The Endpoint for Bitcoin Prices

To fetch Bitcoin prices, we will use a specific public endpoint provided by Kraken:

Endpoint URL: https://api.kraken.com/0/public/Ticker

Query Parameters: To retrieve Bitcoin data, we need to specify the pair parameter. For Bitcoin-to-USD, the parameter is pair=XBTUSD.

Understanding the Response

The response from this endpoint will be in JSON format and will contain several pieces of information, including the current ask price, bid price, and last traded price. Here’s a simplified example of what the response might look like:


{
  "error": [],
  "result": {
    "XXBTZUSD": {
      "a": ["50000.00000", "1", "1.000"],
      "b": ["49995.00000", "1", "1.000"],
      "c": ["50000.00000", "0.00345678"]
    }
  }
}

In this response:

a is the ask array, where a[0] is the best ask price.
b is the bid array, with b[0] being the best bid price.
c is the last trade closed array, c[0] being the last trade price.

Next Steps

With a clear understanding of the Kraken API, particularly the endpoint for fetching Bitcoin prices, we are now ready to move into the practical aspects of using PureScript to make HTTP requests and process this data.

In the following sections, we will discuss how to make HTTP requests in PureScript, parse the JSON responses, and specifically extract the Bitcoin price information from the Kraken API's response. This will involve exploring some of the functional programming paradigms that PureScript offers, ensuring a robust and type-safe approach to interacting with external APIs.

Making HTTP Requests in PureScript

To fetch the Bitcoin price from the Kraken API, we need to make HTTP requests from our PureScript application. PureScript offers several libraries for handling HTTP requests and responses, one of which is purescript-affjax. This section will guide you through using this library to send requests to the Kraken API and handle the responses.

Understanding purescript-affjax

purescript-affjax is a popular library in the PureScript ecosystem for making asynchronous HTTP requests. It uses the Aff monad, which handles asynchronous code in a functional way. This library simplifies the process of making HTTP requests and parsing responses.
Installing purescript-affjax

Before you can use purescript-affjax, you need to add it to your project. You can do this using Spago, the PureScript package manager.

Add the Dependency: Run the following command in your project directory:

spago install affjax

Making a GET Request

To fetch data from the Kraken API, we will use a GET request. Here’s a basic example of how to make a GET request to the Kraken API using purescript-affjax.
Importing Necessary Modules

First, import the necessary modules in your PureScript file:


import Prelude

import Affjax (AJAX, get)
import Affjax.ResponseFormat (json)
import Effect.Aff (launchAff_)
import Effect.Class.Console (log)

Writing the Request Function

Now, let's write a function to perform the GET request:


fetchBitcoinPrice :: Effect Unit
fetchBitcoinPrice = launchAff_ do
  response <- get json "https://api.kraken.com/0/public/Ticker?pair=XBTUSD"
  case response of
    Left error -> log $ "Request failed: " <> show error
    Right res -> log $ "Received response: " <> show res.body

In this function:

launchAff_ is used to execute an asynchronous action.
get json makes a GET request and expects a JSON response.

The URL "https://api.kraken.com/0/public/Ticker?pair=XBTUSD" is the Kraken API endpoint for the Bitcoin price.

The response is either an error (Left error) or a successful response (Right res), which we log to the console. (If you are interested in more details about this topic, I have written about it in detail in the following article: PureScript Get Request - How to Make a HTTP Request in PS )

Running the Function

To run this function, you can call fetchBitcoinPrice from your Main.purs file or wherever you handle your application's entry point.

Next Steps

Having set up the basic structure for making HTTP requests, the next step is to parse the JSON response from the Kraken API. We will need to define PureScript types that correspond to the structure of the API response and write functions to extract the Bitcoin price information. This will involve using PureScript's strong type system to ensure that our data handling is both correct and efficient.

Parsing API Responses

After making an HTTP request to the Kraken API, the next crucial step is parsing the JSON response to extract meaningful data. PureScript, with its strong type system, offers a reliable way to handle JSON parsing. This section will guide you through the process of parsing the Kraken API response and extracting the Bitcoin price information.
Understanding JSON Parsing in PureScript

In PureScript, JSON parsing is typically done using the purescript-foreign-generic library, which provides tools for decoding and encoding JSON in a type-safe manner. This involves defining PureScript types that mirror the structure of the JSON data you expect to receive and then using these types to decode the JSON.

Installing purescript-foreign-generic

If you haven’t already, you'll need to add purescript-foreign-generic to your project:

spago install foreign-generic

Defining PureScript Types for Kraken Response

Based on the structure of the Kraken API response, we'll define corresponding PureScript types. Here's an example:


import Prelude

import Data.Foreign.Class (class Decode, class Encode)
import Data.Foreign.Generic (defaultOptions, genericDecode, genericEncode, Options)
import Foreign.Class (class ReadForeign, read)

-- Define a type for the response
newtype KrakenResponse = KrakenResponse
  { result :: Result
  , error :: Array String
  }

derive instance genericKrakenResponse :: Generic KrakenResponse _
instance decodeKrakenResponse :: Decode KrakenResponse where
  decode = genericDecode defaultOptions
instance encodeKrakenResponse :: Encode KrakenResponse where
  encode = genericEncode defaultOptions

-- Define a type for the Result
type Result = Record (Ticker :: Ticker)

-- Define a type for the Ticker
type Ticker = Record
  ( lastTradePrice :: Array String
  )

derive instance genericTicker :: Generic Ticker _
instance decodeTicker :: Decode Ticker where
  decode = genericDecode defaultOptions
instance encodeTicker :: Encode Ticker where
  encode = genericEncode defaultOptions

Parsing the JSON Response

With the types defined, we can now parse the JSON response from the Kraken API:


parseKrakenResponse :: String -> Either String KrakenResponse
parseKrakenResponse jsonString =
  case read jsonString of
    Left error -> Left $ "Error parsing JSON: " <> show error
    Right value -> case decode value of
      Left error -> Left $ "Error decoding KrakenResponse: " <> show error
      Right response -> Right response

In this function, read attempts to parse the raw JSON string, and decode tries to convert the parsed JSON into our KrakenResponse type. The function returns either an error message or the successfully parsed response.
Extracting Bitcoin Price

Once we have the KrakenResponse, we can extract the Bitcoin price:


extractBitcoinPrice :: KrakenResponse -> Maybe String
extractBitcoinPrice response =
  response.result.XXBTZUSD.lastTradePrice

This function navigates through the KrakenResponse to find the last traded price of Bitcoin.

Next Steps

Now that we have the mechanism to parse the Kraken API response and extract the Bitcoin price, the final step is to integrate this parsing logic with our HTTP request function. We will update the function to not only fetch data from the Kraken API but also to parse the response and extract the relevant Bitcoin price information, handling any potential errors along the way. This will complete our PureScript application for fetching Bitcoin prices from the Kraken API.

Fetching Bitcoin Price from Kraken

Having set up the HTTP request functionality and the JSON parsing mechanism, we are now ready to combine these components to fetch the current Bitcoin price from the Kraken API. This section will walk you through the process of integrating the HTTP request with the JSON parsing to retrieve and display the Bitcoin price.

Integrating HTTP Requests with JSON Parsing

We'll update our fetchBitcoinPrice function to not only make the HTTP request but also to parse the response and extract the Bitcoin price.

Updated fetchBitcoinPrice Function


import Prelude

import Affjax (AJAX, get)
import Affjax.ResponseFormat (json)
import Effect.Aff (Aff, launchAff_)
import Effect.Class.Console (log)

-- Other imports and type definitions from previous sections go here

fetchBitcoinPrice :: Aff Unit
fetchBitcoinPrice = do
  response <- get json "https://api.kraken.com/0/public/Ticker?pair=XBTUSD"
  case response of
    Left error -> 
      log $ "Request failed: " <> show error
    Right res -> 
      case parseKrakenResponse (show res.body) of
        Left parseError -> 
          log $ "Parsing failed: " <> parseError
        Right krakenResponse ->
          case extractBitcoinPrice krakenResponse of
            Nothing ->
              log "Could not extract Bitcoin price."
            Just price ->
              log $ "The current Bitcoin price is: " <> price

launchFetch :: Effect Unit
launchFetch = launchAff_ fetchBitcoinPrice

In this updated function:

We make the GET request to the Kraken API.

If the request is successful, we attempt to parse the response using parseKrakenResponse.

If parsing is successful, we extract the Bitcoin price using extractBitcoinPrice.

Finally, we log the result to the console.

Error Handling

The function includes error handling at each step:

If the HTTP request fails, we log the request error.
If parsing the response fails, we log the parsing error.
If we cannot extract the Bitcoin price, we log an appropriate message.

Running the Application

To run the application and fetch the Bitcoin price, call launchFetch from your application's entry point, typically in the Main.purs file.


module Main where

import Prelude
import Effect (Effect)
import MyModule (launchFetch)  -- Replace with the actual module name

main :: Effect Unit
main = do
  launchFetch

Conclusion

With the fetchBitcoinPrice function in place, your PureScript application is now capable of fetching real-time Bitcoin price data from the Kraken API. This not only demonstrates the power of PureScript in handling HTTP requests and JSON parsing but also gives you a practical tool for cryptocurrency data retrieval.

Remember, this example can be extended or modified to fetch different types of data from the Kraken API or other similar services, showcasing the versatility and capability of PureScript in working with external APIs.

Understanding import and require in JavaScript: A Guide for Beginners

Alexej Bondarenko — Mon, 18 Dec 2023 20:48:41 +0000

JavaScript, a versatile and widely-used programming language, offers two primary methods for importing modules or libraries into your code: import and require. This article aims to clarify these methods for beginner developers, detailing their differences and providing examples of their usage.

1. require: CommonJS Module Syntax

The require function is part of the CommonJS module syntax, predominantly used in Node.js environments. It's known for its dynamic nature, allowing developers to conditionally and programmatically load modules.
How require Works

Syntax: const moduleName = require('module-name');

Functionality: Reads a JavaScript file, executes it, and then proceeds to return the exports object.

Use Case: Typically used in server-side Node.js applications.

Example:


// Importing the 'fs' (file system) module using require
const fs = require('fs');

// Using the imported module to read a file
fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

2. import: ES6 Module Syntax

The import statement, introduced in ECMAScript 2015 (ES6), is used to import functions, objects, or primitives from external modules or files.
How import Works

Syntax: import { moduleName } from 'module-name';

Functionality: It's more static and operates at compile-time, meaning it cannot be called conditionally within the code.

Use Case: Common in front-end JavaScript frameworks like React, Angular, and Vue.js.

Example:


// Importing a specific function from a module
import { readFile } from 'fs';

// Using the imported function
readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

Key Differences

Environment: require is specific to Node.js, while import can be used in both browser and Node.js environments (with transpilers or Node.js versions that support ES Modules).

Syntax: require uses assignment syntax, whereas import has a declarative syntax.

Loading Time: require is runtime/dynamic, and import is static and happens at compile-time.

Conditional Loading: With require, you can conditionally load modules, but import doesn't support this directly.

Native Support: Most modern browsers support import natively, but require needs a bundler like Webpack for browser use.

Conclusion

Understanding the difference between import and require is crucial for JavaScript developers, especially when working across different environments like the server (Node.js) and the browser. While require offers flexibility with dynamic loading, import provides a more declarative and static approach, often resulting in better optimization and error handling.

As you continue your JavaScript journey, experiment with both methods to gain a deeper understanding of their applications and advantages. Remember, the choice between import and require largely depends on your project's environment and specific requirements.

Bunny CDN Purge Cache in Haskell IHP

Alexej Bondarenko — Sun, 17 Dec 2023 23:38:45 +0000

Bunny CDN is a content delivery network (CDN) service. It's designed to help improve the loading times and performance of websites by distributing content across multiple servers located around the world. Our own site - the one that you are reading right now - is using this kind of CDN as well.While writing or correcting articles we came up with the requirement to purge cached articles as soon as they update.

Bunny.net provides an API that allows developers to integrate its services with their applications or websites. This API can be used for various tasks like purging cached content, managing zones, or retrieving usage statistics.
The General Approach to Purge Cache

To create a Haskell program that purges a given URL using the bunny.net API, you would typically use an HTTP client library for Haskell, like http-conduit or wreq. For this article, I'll use http-conduit as it's quite popular and versatile. With the help of this library we will asynchronously send a request to the Bunny API Endpoint.
Implementing purgeCache

First, you need to install the http-conduit package if you haven't already. You can do this using Cabal or Stack. When speaking about IHP - which we are using - we just need to add the http-conduit dependency to the Haskell Packages of the App.

Next, you will need the API-Key provided for your account by Bunny.net. This you can usually find in your account area:

Now, let's write a Haskell function to purge a given URL.

import Network.HTTP.Simple
import Network.HTTP.Types.Method (methodPost)

purgeCdnCache :: (?context :: ControllerContext) => Text -> IO ()
purgeCdnCache url = do
  let BunnyCdnApiKey mBunnyCdnKey = getAppConfig @Config.BunnyCdnApiKey
  case mBunnyCdnKey of
    Just apiKey -> do
      let url' = TE.encodeUtf8 url
      let queryParams = [("url", Just url')]
      let request = setRequestMethod methodPost
                $ setRequestSecure True
                $ setRequestPort 443
                $ setRequestHost "api.bunny.net"
                $ setRequestPath "/purge"
                $ setRequestQueryString queryParams
                $ setRequestHeader "AccessKey" [TE.encodeUtf8 apiKey]
                $ defaultRequest
      _ <- forkIO $ do
          response <- httpJSON request :: IO (Response ())
          putStrLn $ "Purge request sent. Response status code: " ++ show (getResponseStatusCode response)
      pure ()
    Nothing -> do
      pure ()

We can place this code snippet inside the Controller Helper to be able to use the purge function in any Controller of the App.

This function sets up an HTTP POST request to the bunny.net purge endpoint, including the necessary AccessKey headers and Query-Parameters with the according encoding Yoga. We are forking out the request to a new Thread to not block the execution of the Controller Action. The resulting response status code from the bunny.net server is then printed out.

Remember, you'll need to add the necessary imports and probably native SSL Certificate dependencies for your application (cacert).

Also, keep in mind that working with external APIs might require handling various edge cases and error responses for robust production code. This example is a basic demonstration and may need to be adapted for more complex requirements or error handling.

One last detail that needs to be mentioned is the environment variable for our API Key. I have modeled it to be optional since purging is not necessary in all environments of the application (only in production). The way to set up the environment variable is pretty simple and straight forward in the Config.hs file:

bunnyApiKey :: Maybe Text <- envOrNothing "BUNNY_CDN_API_KEY"
option (BunnyCdnApiKey bunnyApiKey)

And here you have it, a working CDN purge cache function! Happy purging!

DEV Community: Alexej Bondarenko

Capitalizing the First Letter in JavaScript

Method 1: Using charAt() and slice()

Method 2: Using Regular Expressions

Method 3: Using ES6 Features

Best Practices and Considerations:

Summary

Lists and LinkedLists in JavaScript

1. Introduction

2. Lists in Java vs. JavaScript

3. LinkedList in Java

4. Linked Lists in JavaScript

5. Why the Difference?

6. Practical Implications

7. Summary

How to Fetch the Bitcoin Price from Kraken API in PureScript

Setting Up Your PureScript Environment

Installation Steps

Installing Spago

Setting Up a New PureScript Project

Exploring the Project

Understanding the Kraken API

What is the Kraken API?

The Endpoint for Bitcoin Prices

Understanding the Response

Next Steps

Making HTTP Requests in PureScript

Understanding purescript-affjax

Making a GET Request

Writing the Request Function

Running the Function

Next Steps

Parsing API Responses

Installing purescript-foreign-generic

Defining PureScript Types for Kraken Response

Parsing the JSON Response

Next Steps

Fetching Bitcoin Price from Kraken

Integrating HTTP Requests with JSON Parsing

In this updated function:

Error Handling

Running the Application

Conclusion

Top 5 Interview Questions for Haskell Developers

1. Explain Monads and Their Significance in Haskell

2. Discuss Lazy Evaluation and Its Benefits and Drawbacks

3. How Does Haskell Handle Null Values? Explain with an Example

4. Describe Type Classes in Haskell and Their Purpose

Conclusion

Understanding import and require in JavaScript: A Guide for Beginners

1. require: CommonJS Module Syntax

2. import: ES6 Module Syntax

Key Differences

Conclusion

Bunny CDN Purge Cache in Haskell IHP