Forem: Harshit Kedia

Idea for a Bitcoin wallet backup service that is non-custodial and fully respects self-sovereignty and privacy

Harshit Kedia — Sat, 21 Feb 2026 12:36:17 +0000

The ethos of Bitcoin is "Not your keys, not your coins." But the terrifying reality for most people is: "Lose your keys, lose your life savings."

We are biological beings. We forget passwords, our houses catch fire, we make mistakes, and eventually, we die. Humans are messy, and that’s okay.

Banks were originally invented to solve this problem—to provide physical security for our assets when we couldn't protect them ourselves. Today, we reject banks because of custody and censorship risks. But what if we could use the Bank's infrastructure (Identity Verification) without giving them Custody of our coins?

I have thought of a protocol architecture that uses BitVM, Smart Contracts, and Bank Wire Memos to create a non-custodial backup system. It allows for inheritance, recovery, and protection against both hackers and rogue companies. This same concept can be applied to protect the user's Nostr keys, or for that matter, any confidential information.

I want to share the architecture and the mitigation of specific threat possibilities - User vs. Company, Company vs. User, and Government vs. User.

The Workflow: Using the Bank as a "Dumb Pipe"

We don't need to partner with banks. We just need to use their output. Banks have already done the heavy lifting of verifying that you are a real human (KYC). We just need to use their public ledger. A Wire Transfer is a cryptographic signal that links a physical identity to a digital action. While I am focusing on wire transfer, note that here we can use other means like Notarized Affidavit, Personal Cheques, etc. also in place of or along with wire transfer to verify identity and create a paper trail.

Phase 1: The Binding (Safety Before Key Generation)

The Handshake: You connect a new Wallet (Hardware wallet preferred for security, but Software wallet works too) to the Backup Service Company's open-source client via internet. An End-to-End Encrypted (E2EE) tunnel is established.
The Code: The Wallet displays an 8-10 digit code on its screen. This is a hash of the current session.
The Signal: You visit your bank for a wire transfer. You send a "Dust" wire transfer (e.g., $1.00) to the Service' bank account. In principle, the backup service should reject wires which came with "Online Transfer" tag in consideration of the risk of hack of the user's net banking account.
- Crucial Step: In the Memo Field, you enter that 8-10 digit code.
The Verification: The Service receives the wire. The employees see "John Doe" sent $1.00 with the correct code. They now know: "The person controlling John Doe's bank account is the person holding this connected Hardware Wallet." In the next step, when the hardware wallet connects to the company service software, the system first verifies that the 8-to-10 digit code generated by the wallet matches exactly what is recorded in the company's database for that specific session. This confirms that the wallet has been rightly identified as belonging to this specific user, effectively linking the wallet to the user via the bank's human identification process.
The Generation: To ensure the Service acts as "Blind Storage" and never sees the seed phrase as plain text, we use Witness Encryption logic via BitVM/Zero-Knowledge proofs.
- For setting the backup (Phase 1) of the original wallet, we use "Blind" Encryption Protocol (Witness Encryption). Instead of giving the Service a key, we use Commutative Encryption.
- Setup: You connect the wallet back to the service's client, your Wallet generates a random key ($K$) and encrypts the Seed Phrase.
- The Puzzle: Your Wallet encrypts $K$ into a Mathematical Puzzle (Witness Encryption). The rule is: "This puzzle can only be transformed if a valid Bank Wire Proof + 7 Days Time is provided."
- Storage: The Service stores the Encrypted Seed and the Puzzle. They physically cannot decrypt it because they lack the "Witness" (the Proof of Wire) to solve the encryption equation.

Risk: Can the Service simply lie, claim they received a wire, and secretly decrypt my data?
Defense: The "Loud" Timer.
- The 7-Day Time-Lock is a Blockchain Logic, not a server clock.
- To start the timer, the Service must publish a "Recovery Initiation" transaction on the public ledger.
- You cannot hide a transaction on a public blockchain.
- The moment they press that button, the Watchtower detects the on-chain event and alerts you.
- Since the Encryption Puzzle requires the completion of the 7-day on-chain period, the Service cannot decrypt anything until the time is up. This gives you 7 days to broadcast a VETO transaction, which creates a mathematical block that makes the puzzle unsolvable forever.
Result: The Service holds your backup, but they cannot read it. They just act as a storage locker.

Phase 2: The Recovery (and Inheritance)

Years later, you lose your device. Or perhaps you pass away, and your heir needs access.

The Request: You (or your heir) buy a new wallet. You connect to the Service.
The Proof: You (or the heir via probate/law) send another $1.00 wire from the registered bank account. You include the new session code in the Memo.
The Match: The Service matches the Sender Name and the Memo Code.
The Time-Lock: The Service initiates a "Release Transaction" on the Smart Contract with a 3-to-7 Day Time-Lock. The count of the days depends on how much delay the user configured while opting the service.
The Release: When the Time-Lock and Bank Wire conditions are met (and no veto is issued), the Service does not decrypt the blob. The Smart Contract performs an Atomic Re-Encryption. It applies the New Wallet's Key (Key B) on top of the blob, and then effectively "subtracts" Key A. The ZK Circuit proves: "I know the Witness (Wire Transfer + Time) that decrypted Key A. But the ZK Proof does not reveal the Witness itself. The public (and the Service) only sees the Proof (a small string of characters) that says "This operation was valid," not the underlying secret that made it valid, therefore the old "decryption key" for Key A (the Witness) does not become public for anyone to use it to decrypt the original blob.

The Result: The blob transitions from being locked by the Old Wallet to being locked by the New Wallet without ever being decrypted in the middle. The Service holds the data, but the math prevents them from reading it. The user's wallet decrypts the data with Key B after receiving it. Funds are recovered.

Note for Inheritance: This solves the "Dead Man's Switch" problem. Heirs may not have the wallet's seed phrase, but they just need access to the bank account, and they perform a simple wire transfer.

The Threat Models (How everyone is protected)

This is where the protocol shines. It protects the User, but it also protects the Service.

1. User vs. "Rogue Company" (The Imposter Attack)

Risk: What if a rogue employee at the Service tries to fake a request to steal your backup?
Defense A (Encryption): The employee cannot decrypt the blob. They only steal useless cyphertext.
Defense B (The Smart Contract): The logic is on BitVM, not the company server. The company cannot force an immediate release. They must wait the 7 days.
Defense C (The Watchtower): During that 7-day window, you (the user through his phone, email, and wallet) get an alert through a watchtower service. You can use your original wallet to VETO the transaction on the Smart Contract. You can prove to the public that company was trying to steal funds, as you didn't make any wire transfer request. If proven guilty then the company would have reputational and legal consequences.

2. Protection: Company vs. "Lying User" (Defamation)

Scenario: A user initiates a recovery, gets his keys, and then publicly claims: "The Service hacked me! I never asked for this recovery!"

Defense: The Service points to the Bank Ledger. They can publicly prove: "Here is a Wire Transfer from your specific Bank Account, on this specific date, containing the specific 8-digit Code that authorized this release."
Because the Wire Transfer is a regulated financial event, it acts as an immutable "Proof of Intent." The user cannot claim impersonation unless they admit their own bank was compromised. Supplementary checks (Video calls, SMS, Email communication) can exist as layers, of which the company can have a record with themselves - these layers may work in the same way as users are assisted by social media or financial companies when the user has forgotten the credentials for his account on their platform, but the "Base Layer" is the financial/legal record.

3. Protection: User vs. Government/Censorship

This is the critical defense mechanism.

Scenario: A hostile government forces the Company (or seizes their servers) to initiate a recovery for your wallet, claiming they are you.

The Company is forced to press the "Wire Received" button even though you didn't send one.
The Defense: The 7-Day Timer starts. You (the user) receive an alert on your phone: "Recovery Initiated."

You now have two options:

Option A: The Veto (If you are safe) You use your original wallet or a secondary key to VETO the transaction on-chain. The attack fails immediately.

Option B: Plausible Deniability (If you are under duress) If the government is standing over your shoulder forcing you to let the timer run out:

You use a special "Duress Signal" (e.g., pointing the recovery to a specific decoy address).
The Zero-Knowledge Proof generates a valid-looking decryption key.
However, this key decrypts a "Dummy Wallet" containing a small amount of "decoy" funds.
The government sees the wallet open, sees the funds, and believes they have succeeded.
Crucially: Because of the Zero-Knowledge nature of the proof, they cannot mathematically prove that this is a dummy wallet. Your real stash remains hidden and encrypted forever.

4. Protection: Service vs. Geopolitics

Scenario: The Service's servers are destroyed or seized in a specific country.

Defense: Since the data is encrypted blobs, it can be stored on IPFS or decentralized servers globally. As long as the user has their identity (Bank Account) and the Service has the "Oracle" key to verify the wire, the service can be spun up anywhere in the world. Furthermore, each user can avail service from multiple backup companies so that if one of them is knocked down then he has other ones as backup.

Summary

We are trying to bridge the gap between "Code is Law" and "Humans make mistakes."

By using the Wire Memo as a high-fidelity, we can create a system where:

No new KYC is needed (Your bank already did it).
No Custody is given (Everything is encrypted client-side).
Inheritance is solved (Legacy banking rails handle the access control).

Future Evolution: Native Bank APIs & Digital Signatures

Currently, this protocol relies on a functional "hack" of the legacy system: the wire memo. This is also more of an approach for kick starting the process. However, as adoption grows, banks will recognize the utility (and market potential) of serving as a formal identity anchor for digital assets.

We anticipate a shift toward direct API collaboration between banks and Backup Services. Instead of a service employee manually inputting the 8-to-10 digit code from a screen, the bank’s API could push a confirmation directly to the Service.

Crucially, this allows us to integrate Bank-Signed Digital Signatures directly into the BitVM Zero-Knowledge circuit. The "Witness" essentially evolves from a legal paper trail into a cryptographic proof. This eliminates the need for human verification at the Service level, reduces the scope for error, and creates a fully automated, trust-minimized bridge between fiat identity and crypto custody.

I believe this is how we onboard the next billion users—by giving them a safety net that relies on math and existing infrastructure, not on trusting a CEO.

Update: Addressing Edge Cases (Internal Theft & Government Detention)

Thank you for the feedback on the initial architecture. Two critical "human" edge cases were raised:

The "Family" Risk: What if someone with shared access to your bank account (like a spouse) tries to initiate a recovery behind your back?
The "Detention" Risk: How do you issue a "Duress Signal" if you are physically detained by a government and can’t access your devices?

Here is how we have refined the protocol to mitigate these threats while maintaining trust-minimization.

1. The "Distributed Duress" Network (Guardian Protocol)

To solve the detention problem, we introduce Guardians. These are $N$ people (friends/family/lawyers) you trust. However, we handle this differently than standard social recovery to avoid extortion and collusion.

Silent by Default: When you initiate a legitimate recovery, your Guardians are not notified. This is crucial. If they don't know a recovery is happening, they cannot extort you for a "cut" of the funds.
The External Signal: Guardians only act when they have external knowledge that you are in trouble (e.g., they see you’ve been arrested in the news, or you’ve disappeared).
The Duress Button: If a Guardian sees a "Recovery Initiation" on the public ledger during the 7-day window and knows you are under duress, they can broadcast a "Duress Signal."
Decentralized Veto/Redirection: This signal can either move the recovery to a pre-set "Safe Harbor" address or trigger the "Decoy Wallet" logic mentioned in the original post. When you're set free then you can use your original wallet for master control.

2. Mitigating Guardian Malice (The "Extortion" Case)

A common concern with social recovery is: "What if my friend turns on me and hits the Duress button just to mess with my recovery?"

Game Theory & Overrides: We use an $M$-of-$N$ logic. For example, if you have 3 Guardians, you can set the protocol so that if 1 Guardian hits "Duress" maliciously, the other 2 (or you, the user) can Veto/Override that signal within the 7-day window.
Privacy of Guardians: The Guardians should not know who the other Guardians are. The user registers them independently. This prevents the "Ocean’s Eleven" scenario where your friends huddle together to coordinate an attack against you.

3. Protection Against Internal/Family Theft

If a family member with bank access initiates a wire transfer to steal your keys:

The "Loud" Alert: Since the 7-day timer is on-chain, your primary wallet and phone (which the family member may not have access to) will receive a notification immediately.
The Hardware Veto: As long as you have your hardware wallet or a secondary "Veto Key," you can kill the transaction instantly.
The Bank Record: Because the recovery is tied to a wire transfer, there is a legal paper trail. If a family member does this, they have committed a documented financial crime (unauthorized transfer), making it much easier to prosecute or reverse in a court of law compared to a typical "hacked" seed phrase.

4. The Company Reputation Defense

Finally, regarding Government vs. User: A backup service’s primary product is security. Just as high-end VPNs or encrypted mail services (like Proton) have historically fought or ignored government "data requests" to protect their brand, a non-custodial backup service has a massive market incentive to reject suspicious recovery requests.

If the media reports a user is in detention, and the service sees a "forced" wire transfer request from that user’s account, the service can (and should) flag that request as "High Risk" and pause it, citing the protocol’s duress protections.

I am looking for feedback:

Are there edge cases in the "Dust Transaction" I'm missing?
Would you feel secure knowing your encrypted backup is held by a service, protected by a 7-day time-lock and your regional bank?

Function calling with Google Gemini chat AI

Harshit Kedia — Tue, 24 Dec 2024 14:35:24 +0000

Function calling enables developers to incorporte custom functions or APIs with a generative AI chat application

The AI model decides if any of the functions and APIs is useful for answering the user query, and the AI model responds with the functions and their arguments to be used

The functions need to be well described with the arguments, their argument data types and the returning values

In this tutorial we will explore parallel function calling with Python, using Google Gemini AI, with external APIs providing city's population and country's currency used, for answering user questions

import requests
import json
import google.generativeai as genai

Add your API key and select the model

genai.configure(api_key="YOUR API KEY")
model = genai.GenerativeModel("gemini-1.5-flash")
response = model.generate_content("What is the date today?")
print(response.text)

Today is October 26, 2023.

Define function to be used in function calling

#### Ensure to specify the datatype of arguments used in the function,
#### otherwise it will give error in function calling

def set_light_values(brightness: int, color_temp: str):
    """Set the brightness and color temperature of a room light. (mock API).

    Args:
        brightness: Light level from 0 to 100. Zero is off and 100 is full brightness
        color_temp: Color temperature of the light fixture, which can be `daylight`, `cool` or `warm`.

    Returns:
        A dictionary containing the set brightness and color temperature.
    """
    return {
        "brightness": brightness,
        "colorTemperature": color_temp
    }

set_light_values(brightness=30,color_temp="daylight")

{'brightness': 30, 'colorTemperature': 'daylight'}

Select the model and specify the tool to be used in function calling

model = genai.GenerativeModel(model_name='gemini-1.5-flash',
                              tools=[set_light_values])

The response generated from the input will contain the suggested functions and arguments the chat model suggests

chat = model.start_chat()
response = chat.send_message('Dim the lights so the room feels cozy and warm.')

response

response:
GenerateContentResponse(
    done=True,
    iterator=None,
    result=protos.GenerateContentResponse({
      "candidates": [
        {
          "content": {
            "parts": [
              {
                "function_call": {
                  "name": "set_light_values",
                  "args": {
                    "brightness": 30.0,
                    "color_temp": "warm"
                  }
                }
              }
            ],
            "role": "model"
          },
          "finish_reason": "STOP",
          "avg_logprobs": -0.0008751733228564262
        }
      ],
      "usage_metadata": {
        "prompt_token_count": 150,
        "candidates_token_count": 10,
        "total_token_count": 160
      }
    }),
)

Evaluate the functions with the arguments the chat model suggests and store the functions with their corresponding values returned, as a JSON object

def function_used_and_their_outputs(functions,response):
  for part in response.parts:
      #### in every iteration, fn is assigned a function used by AI during the function call
      if fn := part.function_call:
          #### args gets assigned a string value like "brightness=30.0, color_temp='warm'",
          #### repr() is used to add quotes to the keys like 'warm',
          #### repr() is used so string value keys are treated as string, not variable
          args = ", ".join(f"{key}={repr(val)}" for key, val in fn.args.items())
          print("arguments are: ", args)
          #### Function is being generated using f strings
          function_to_be_called = f"{fn.name}({args})"
          print("function being called using eval, with arguments: ", function_to_be_called)
          output=eval(function_to_be_called)
          functions[fn.name]=output

house_functions={}
function_used_and_their_outputs(house_functions,response)
house_functions

arguments are:  brightness=30.0, color_temp='warm'
function being called using eval, with arguments:  set_light_values(brightness=30.0, color_temp='warm')





{'set_light_values': {'brightness': 30.0, 'colorTemperature': 'warm'}}

Provide the JSON object back to the generative chat function to get AI generated response processing the outputs of the functions

def response_based_on_used_functions(functions):
  response_parts = [
      genai.protos.Part(function_response=genai.protos.FunctionResponse(name=fn, response={"result": val}))
      for fn, val in functions.items()
  ]

  response = chat.send_message(response_parts)
  print(response.text)

response_based_on_used_functions(house_functions)

OK. I've dimmed the lights to 30% brightness and set the color temperature to warm.  Is there anything else?

Defining functions to get population and currency of input city and country respectively

def get_population(city: str):
  """Gets population of a city and year of count.

  Args:
    city: The name of the city.

  Returns:
    JSON object encapsulating the population of the city and year of count if function executed successfully, else, an error message.
  """
  url = "https://countriesnow.space/api/v0.1/countries/population/cities"

  payload = {"city": city}
  headers = {}

  response = requests.request("POST", url, headers=headers, data=payload)
  json_data=json.loads(response.text)

  if json_data['error']:
    return json_data['msg']
  else:
    return {'population':json_data['data']['populationCounts'][0]['value'],'year of counting':json_data['data']['populationCounts'][0]['year']}

get_population('amsterdam')

{'population': '779808', 'year of counting': '2011'}

def get_currency(country_code: str):
  """Gets information about the currency used in the country

  Args:
      country_code (str): The alphabetical country code of the country, eg.: if referring to Nigeria, then argument passed will be its alphabetical country code NG

  Returns:
    JSON object encapsulating the currency used in the country if function executed successfully, else, an error message is returned.
  """
  url = "https://countriesnow.space/api/v0.1/countries/currency"

  payload = {"iso2":country_code}
  headers = {}

  response = requests.request("POST", url, headers=headers, data=payload)

  json_data=json.loads(response.text)

  if json_data['error']:
    return json_data['msg']
  else:
    return json_data['data']['currency']

get_currency('pk')

'PKR'

demography_functions=[get_population, get_currency]
model = genai.GenerativeModel(model_name="gemini-1.5-flash", tools=demography_functions)

chat = model.start_chat()

In the following example, notice that both, the population and currency functions are being called by the AI chat when population and currency are being asked by user, also notice that the AI is using its own knowledge to identify the country in which the city asked by the user is located, to send the corresponding country code as the argument to the currency function

response = chat.send_message('Tell about the population and currency used in delhi')
demography_functions_used={}
function_used_and_their_outputs(demography_functions_used,response)
demography_functions_used

arguments are:  city='Delhi'
function being called using eval, with arguments:  get_population(city='Delhi')
arguments are:  country_code='IN'
function being called using eval, with arguments:  get_currency(country_code='IN')





{'get_population': {'population': '9879172', 'year of counting': '2001'},
 'get_currency': 'INR'}

response_based_on_used_functions(demography_functions_used)

The population of Delhi was 9,879,172 in 2001. The currency used in India, where Delhi is located, is the Indian Rupee (INR).

In the following 2 examples, notice that only the population function is being called by the AI chat when only population is asked by user

response = chat.send_message('Tell about the population of Tokyo')
demography_functions_used={}
function_used_and_their_outputs(demography_functions_used,response)
response_based_on_used_functions(demography_functions_used)

arguments are:  city='Tokyo'
function being called using eval, with arguments:  get_population(city='Tokyo')
The population of Tokyo was 8,945,695 in 2010.

Due to some reason, the API isn't able to fetch the population of New York, which the AI chat achnowledges

response = chat.send_message('Tell about the population of new york')
demography_functions_used={}
function_used_and_their_outputs(demography_functions_used,response)
response_based_on_used_functions(demography_functions_used)

arguments are:  city='New York'
function being called using eval, with arguments:  get_population(city='New York')
I'm sorry, I couldn't find information about the population of New York.

In the following examples, notice that only the currency function is being called by the AI chat when only currency is asked by user

response = chat.send_message('Tell about the currency of london')
demography_functions_used={}
function_used_and_their_outputs(demography_functions_used,response)
response_based_on_used_functions(demography_functions_used)

arguments are:  country_code='GB'
function being called using eval, with arguments:  get_currency(country_code='GB')
The currency used in London, United Kingdom is the British Pound (GBP).

– I am Harshit from India. I am exploring generative AI, data science and machine learning. To collaborate, let's connect on linkedin and twitter 😊

Useful insights I got while building web development projects

Harshit Kedia — Sat, 17 Feb 2024 10:42:04 +0000

Building a music player web app like spotify using HTML, CSS and Javascript!

Currently working on building a section for showing the list of songs in the library. Here are some interesting insights:

Using CSS, the list style of an unordered list (UL) can be modified to none if we want to remove bullet points, it can be set to any other style as well. We can modify the list-style-type to number to use it as an ordered list.

The getElementByTagName returns array of the tags present, for the particular tag we are searching, to use a particular one we have to refer to the position in the array like arr[0], it can also be nested with querySelector if we want to use it in a particular element having an id, similarly, multiple getElementByTagName can be combined by referring to their respective positions in their arrays.

Forof loop can be used for iteration in an array. To return it in HTML in the desired format we can use a template literal to concatenate the outputs of the iteration. Ex: use songUL.innerHTML += <li> ${song} </li> where songUL is a UL with that id, and ‘song’ is the output of iteration in ‘songs’ array.

If we fetch data from a URL of our server, for instance here I want to fetch the list of songs in my database, it will return the array with special characters replaced with encoding. For example: spacebar (‘ ‘) will be returned with ‘%20’, so while returning the output we need to use replaceAll (not ‘replace’ because it will only replace the first instance). Also, using ‘split’ to break the string into 2 parts will give an array with 2 elements, one left part of the string and another one right part, so use [1] in the output array to get the right part of the string.

I wanted to put a ‘play now’ text to appear if i am hovering over an associated image of the play icon. The hovering happening on one element to bring effect on another element can be brought by keeping the text element’s display as none and then keeping the following CSS:

#imgToBeHovered:hover ~ #textToBeDisplayedUponHover{
    display: block;
}

//here imgToBeHovered and textToBeDisplayedUponHover are id names of the elements.

Associated github repository: https://github.com/Harshitnitw/spotify-clone/

– I am Harshit from Varanasi, India, anyone interested in science, technology, etc and would like to learn and grow together, feel free to DM 😊

Created a Weather web app using HTML, CSS and Javascript

Harshit Kedia — Thu, 11 Jan 2024 15:09:27 +0000

Basic idea is, we have an input field and submit button in a div, styled with CSS. Clicking the submit button invokes a function which inputs the city using document object model (DOM) query selector and we fetch an API with API key and city name as a query. Relevant data is extracted and displayed with a CSS styled div again selected using DOM.

Link of the weather app: https://weather-app-using-html-css-and-javascript.vercel.app/

We have an error display message which is styled as display: none by default, and is changed to display: block if the fetch method returns a 404 response, if the user enters an incorrect city name.

We also have an associated image displayed corresponding to the weather, which the instructor selected using if-else statement based on the weather property returned by the API, however, I used string interpolation with placeholder ${} to use the weather property to output file names directly, somewhat like images/${weather}.png and thus improved the code efficiency.

Link of associated code: https://github.com/Harshitnitw/Weather-App-using-HTML--CSS-and-Javascript

Thanks to GreatStack youtube channel for providing the learning experience: https://youtu.be/G0jO8kUrg-I?si=PxYmpNP420Et9LAp

Feel free to reach me out if you would like to learn and grow together 😄

Made a shopping cart web app using HTML, CSS and Javascript

Harshit Kedia — Sat, 06 Jan 2024 12:32:55 +0000

erent items, and the total amount along with the items is displayed on the cart page. The website is dynamic and allows editing the choice of items both on the store and on the cart page.

Link to the web app: https://shopping-cart-app-with-html-css-and-javascript.vercel.app/index.html

We have unique IDs of the shopping items whose details are stored in a js file, which behaves as a key for identifying the quantity, price, etc of the item which the user selects. Javascript is used to generate a loop which renders the details based on the HTML template designed.

Associated cards are dynamically programmed to identify specific elements, and results are rendered using the document object model (DOM). User’s selections are saved in the browser memory so that they reload after refresh.

Link to the source code: https://github.com/Harshitnitw/shopping-cart-app-with-HTML--CSS-and-Javascript

Thanks to Freecodecamp and the instructor Joy Shaheb for providing the learning opportunity. Associated tutorial: https://youtu.be/cT_ZYrS3tKc

It was delightful for me to be able to apply my own ideas to reduce redundancy, avoid unused code and apply alternative techniques to load the pages faster, to improve upon the tutor’s project, which enhanced my learning experience manyfolds!

Useful Javascript ES6 nuggets

Harshit Kedia — Sat, 09 Dec 2023 09:34:28 +0000

Important points I noted while revising Javascript ES6:

:> Adding external script to webpage:

<script type="module" src="index.js"></script>

:> Exporting function to Share a Code Block:

export const add = (x, y) => {
  return x + y;
}

*Export multiple things by repeating for each export.

:> Reusing JavaScript Code Using import:

import { add, subtract } from './math_functions.js';

*Here ./ tells the import to look for the math_functions.js file in the same folder as the current file.

:> Import Everything from a File and use specific functions:

import * as myMathModule from "./math_functions.js";
myMathModule.add(2,3);
myMathModule.subtract(5,3);

:> For default export functions, while importing, no need to add braces {}, and name can be anything, not compulsorily the name of the function.

:> Promise: task completes, you either fulfill your promise or fail to do so, with two parameters - resolve and reject, to determine the outcome of the promise. Syntax:

const myPromise = new Promise((resolve, reject) => {
  if(condition here) {
    resolve("Promise was fulfilled");
  } else {
    reject("Promise was rejected");
  }
});

:> When you make a server request it takes some amount of time, and after it completes you usually want to do something with the response from the server. The then method is executed immediately after your promise is fulfilled with resolve, eg:

myPromise.then(result => {});

:> Catch can be executed if after a promise's reject method is called:

myPromise.catch(error => {});

Useful javascript ES6 nuggets

Harshit Kedia — Fri, 08 Dec 2023 07:18:26 +0000

Some important points I summarized while revising ES6 from freecodecamp:

:> Using Destructuring Assignment to Assign Variables from Nested Objects:
Eg: we have object LOCAL_FORECAST:

const LOCAL_FORECAST = {
  yesterday: { low: 61, high: 75 },
  today: { low: 64, high: 77 },
  tomorrow: { low: 68, high: 80 }
};

We assign variables lowToday and highToday with values LOCAL_FORECAST.today.low and LOCAL_FORECAST.today.high wusing this one liner code:

const {today:{low:lowToday,high:highToday}}=LOCAL_FORECAST

:> We can access the value at any index in an array with destructuring by using commas to reach the desired index:

const [a, b,,, c] = [1, 2, 3, 4, 5, 6];

The values of a, b, and c become 1, 2 and 5 respectively.

*Using destructuring assignment to swap the values of a and b, if we re-declare a or b while destructuring if already declared in the first let statement, then it will give an error. Eg, below code will give error:

let a = 8, b = 6;
const [b,a]=[a,b]

Correct way is:

let a = 8, b = 6;
[b,a]=[a,b]

*also, using const instead of let will give error above

const [a, b, ...arr] = [1, 2, 3, 4, 5, 7];
Here a, b and arr are new objects declared and their values are 1, 2 and [3, 4, 5, 7] respectively.
*behavior is similar to Array.prototype.slice()

:> Using Destructuring Assignment to Pass an Object as a Function's Parameters

const profileUpdate = (profileData) => {
  const { name, age, nationality, location } = profileData;
}

can be effectively written as:
const profileUpdate = ({ name, age, nationality, location }) => {}

:> Creating Strings using Template Literals:
Syntax: Can add ${obj.prop}
*We use backticks, not inverted commas, put the value as ${object.property} and there is no need of putting \n for new line, we can include expressions in string literal, eg: ${a + b}

:> ES6 provides syntax to eliminate the redundancy of having to write x: x. You can simply write x once, and it will be converted tox: x (or something equivalent) for and as in the following:
const getMousePosition = (x, y) => ({ x, y });

:> Example of using function in an object in ES6:

const bicycle = {
  gear: 2,
  setGear(newGear) {
    this.gear = newGear;
  }
};

Useful Javascript ES6 nuggets

Harshit Kedia — Sun, 03 Dec 2023 15:41:48 +0000

Useful Javascript ES6 nuggets:

Started learning ES6 from freecodecamp, some useful points I Summarized:

:> Global scope of var vs local scope of let:

var printNumTwo;
for (var i = 0; i < 3; i++) {
  if (i === 2) {
    printNumTwo = function() {
      return i;
    };
  }
}
console.log(printNumTwo());

Here, printNumTwo() prints 3 and not 2. This is because the value assigned to i was updated and the printNumTwo() returns the global i and not the value i had when the function was created in the for loop. The let keyword does not follow this behavior:

let printNumTwo;
for (let i = 0; i < 3; i++) {
  if (i === 2) {
    printNumTwo = function() {
      return i;
    };
  }
}
console.log(printNumTwo());
console.log(i);

Here the console will display the value 2, and an error that i is not defined, because let's scope is limited to the block, function or statement in which you declare it.

*I noticed that we need to change javascript to strict mode by writing "use strict" at the beginning of the code for the solution of 'let' keyword to work.

:> Const declaration alone doesn't really protect your data from mutation, like adding/changing elements or properties in arrays or objects respectively. To ensure your data doesn't change, JavaScript provides a freeze function to prevent data mutation. Syntax: Object.freeze(arr)

:> Syntax of inline function without name:

const myFunc = function(argument) {
  const myVar = "value";
  return myVar;
}

const myFunc = (argument) => {
  const myVar = "value";
  return myVar;
}

:> Default parameters in function kick in when the argument is not specified (it is undefined). Ex:

const greeting = (name = "Anonymous") => "Hello " + name;

console.log(greeting("John"));
console.log(greeting());

:> Rest parameter (...args) helps create functions that take a variable number of arguments, eg:

function howMany(...args) {
  return "You have passed " + args.length + " arguments.";
}
console.log(howMany(0, 1, 2));
console.log(howMany("string", null, [1, 2, 3], { }));

:> Spread operator allows us to expand arrays and other expressions, eg:

const arr = [6, 89, 3, 45];
const maximus = Math.max(...arr);

*can also use Math.max.apply(null,arr)

:> Spread operator only works in-place, like in an argument to a function or in an array literal, i.e. the following code will not work:

const spreaded = ...arr; // use [...arr]

:> Equivalent for

const name = user.name;
const age = user.age;

is
const { name, age } = user;
OR
const { name: userName, age: userAge } = user;
*new variable names are userName and userAge

Useful Javascript nuggets

Harshit Kedia — Sat, 02 Dec 2023 10:36:10 +0000

Finished revising basic javascript from freecodecamp, noted some important points:

-> For a multi-dimensional array, we can use the following logic to loop through both the array and any sub-arrays, when the length of the arrays vary or is unknown:

const arr = [ [1, 2], [3, 4], [5, 6] ];

for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr[i].length; j++) {
console.log(arr[i][j]);
}
}

-> Recursion (function calling upon itself): For multiplying the first n elements of an array:
multiply(arr, n) == multiply(arr, n - 1) * arr[n - 1]
Therefore the code can be:
function multiply(arr, n) {
if (n <= 0) {
return 1;
} else {
return multiply(arr, n - 1) * arr[n - 1];
}
}
*Recursive functions must have a base case when they return without calling the function again (in this example, when n <= 0), otherwise they can never finish executing.

-> Formula to generate a random whole number in the range from given min to max:
Math.floor(Math.random() * (max - min + 1)) + min

-> parseInt(string, radix)
Radix specifies the base of the number in the string, which can be an integer between 2 and 36, stores the parsed input as integer. Eg: in the following code, 11 is in the binary system, or base 2:
const a = parseInt("11", 2);

-> Code for an array of 1 to N using recursion:
function countup(n) {
if (n < 1) {
return [];
} else {
const countArray = countup(n - 1);
countArray.push(n);
return countArray;
}
}
*The array returned here is from 1 to N and not from N to 1 because at the point where n is pushed into the array, countup(n - 1) has already been evaluated and returned.

Useful javascript nuggets

Harshit Kedia — Thu, 30 Nov 2023 15:49:18 +0000

Revised javascript objects, noted some useful points:

We can omit the quotes for single-word string properties, like make in the following example-
const anotherObject = {
make: "Ford",
5: "five",
"model": "focus"
};
*Notice 5, we can also use numbers as properties.

If the property of the object we are trying to access has a space in its name, we need to use bracket notation, ex: myObj["Space Name"];

We can add new properties to existing JavaScript objects the same way you would modify them. Ex: ourDog.bark = "bow-wow"; // bark property was not declared initially

delete properties from objects like this: delete ourDog.bark;

someObject.hasOwnProperty(someProperty) returns true or false depending on if the property is found on the object or not

*In a code, records[id][prop].push(value) was giving error because the array was not defined in some cases, so changed the code to:
const arr = records[id][prop] || []
arr.push(value)
records[id][prop]=arr