DEV Community: Nimit Savant

Why Developer Advocacy Matters in India: A Guide for Aspiring Advocates

Nimit Savant — Sat, 06 Sep 2025 21:34:58 +0000

Inception

In the rapidly evolving tech landscape of India, Developer Advocacy has emerged as a crucial role that bridges the gap between developers and technology companies. For students and budding developers, understanding the importance of Developer Advocacy can open new pathways for learning, growth, and community engagement.

What is Developer Advocacy?

Developer Advocacy is a role focused on building and nurturing relationships between a company and the developer community. Developer Advocates act as the voice of developers within organizations and the voice of the company within the developer ecosystem. They create content, organize events, provide feedback, and foster a collaborative environment that benefits both developers and businesses.

Why is Developer Advocacy Important in India?

Bridging the Gap Between Developers and Companies: Many developers in India face challenges in accessing the latest tools, APIs, and platforms. Developer Advocates help bridge this gap by translating complex technical information into accessible knowledge, organizing workshops, webinars, and hackathons that bring developers closer to cutting-edge technology.
Low visibility of roles: In terms of both ends _> students and C level executives aren't aware of the role and it's importance. Because there are very few use cases and lack of educational material to support the case. From students POV, this is a high risk role, and from companies perspective they don't know what would the ROI. Matching this is as simple as writing a small article about your experience (which is what I'm trying to do with my experience)
Fostering collaboration between products: The easiest way to show impact is something I learnt from a Dev Advocate, to show how to integrate each other's tool and create complex yet very useful POCs. These would drive adoption rates to sky. Making integration for a platform or having another dev tool on your product. These kinds of colloborations would only be prioritized if there's a business need, but Dev Advocates make a space where these are already available and help drive the funnel for colloborations from get go.

How can you start contributing to the ecosystem of Developer Advocacy or become one?

Learning Pathways to Become a Developer Advocate

Build Strong Technical Foundations: Pick a language, framework, OS or AI tool you're found of and try to make POCs where to showcase your skills. The more technical depth you bring the more you can contribute.
Engage with Developer Communities: This is a given, the first step itself is to start posting in communities and IRCs to know more about the tech you're contributing to and showing visibility for yourself in the community.
Communication Skills: The most important skills that you might want to develop would be communicating with fellow developers and driving value in your conversations about the topic you're talking about. Always remaining in community guidelines and have a helping nature in your tone.
Seek Mentorship and Role Models: Developer Advocacy is relatively very new, if you want to learn and grow fast _> keep asking questions to the folks who're already doing well, but don't spam them with questions on the basics do your research, keep a tab of active questions and reach out to them with well directed questions which they can directly answer.
- Not a good example❌ _> hey there, I'm xoxo reaching out. Just wanted to say hi and talk to you about your role and take guidance.
- Good example ✅ _> Hey Nimit, I was reading about this article on Dev Advocacy (link) what do you think about the right approach to talk drive audience interaction and create the right messaging for a developer advocacy event, thank you.
Contribute to Open Source: You would be already using something open source in your daily tech jobs/college projects which you would love to talk about or contribute back to. Find the #goodfirstissues in the open source repo and start contributing with docs, and slowly leaning on to some smaller tasks. This is not important to flex, but this is to build confidence in your own self the work you're doing is being used by millions/billions of developers out there; and your contribution has a wider impact.

Conclusion

Developer Advocacy is more than a job; it’s a mission to empower developers, foster innovation, and build vibrant communities. For students in India, stepping into this role offers a chance to grow technically, connect deeply with the tech ecosystem, and make a meaningful impact.
If you’re passionate about technology and community, Developer Advocacy might just be the perfect path for you.

Drop your questions in comment section, I would love to answer them 🥑

How to build your first Tech Community?

Nimit Savant — Thu, 18 Apr 2024 17:49:24 +0000

Background

Tech communities are the most pivotal infrastructure of a tech company. Because they help them understand flaws in the product first hand and also give them an audience who believes in their initiatives. It's always said the best way of marketing something is through "Word of mouth" and thus communities who have succeeded in past have understood their audience in a better way.

Introduction

Tech communities are gateway for your product into the market of community and creating an ecosystem. You can do wonders with touching base on different avenues with your vision with these communities. Further in this blog I will give you folks an understanding to how that would happen.

Let's for starters define Tech Communities. They're a space you create for your direct developer audience and clients. This could generally be on a platform like Discord, Slack, Forums SaaS apps. You provide a number of things for their support here

Support channel
Channel for sharing their demos and products build on your stack
Organizing AMA/Office hours
Organizing Hackathons/Tech Events

Dive In

Let's dive in to understand in detail how you would start with your first tech community! For this journey we will take example of an Open Source Database company "Looping DB" who wants to create a community around their product.

Step 1: Jot down why are you creating a community in the first place, what are the end goals and what is your target audience.

Looping DB Example

Looping DB wants to create a community because they want to understand the market fit for their product and get feedback from developers.
Their end goal is to get more developers on their cloud platform availing the free plan. So that they can convert these users later into paid ones. But they also want people to self host their DB and get feedback on the open source path.
Their target audience is actually corporate who want to scale from 10k-1M reads/writes.

Step 2: Figure out strategies to announce your community and get the initial 1-100 developer with you. Don't re-invent the wheel, churn the wheel according to your needs.

Hackathons
Tech event/challenge online
Community partners with other Tech communities and announcing an event/article/community collaboration with them
Creating awareness about community support on your website and socials

Looping DB Example

Looping DB started with an hackathon on Devfolio or Devpost. Collaborated with few more community partners and hosted this event. they got an outreach of about 100 participants online joining they're community.
They changed their website's landing page and shared information about the hackathon, made people aware about how one can get community support.

Step 3: Interact, gratify and support, very simple but very difficult if you don't have the right people doing this for you.

Interact: You need moderators, to make a very interactive environment for your community. As soon as developers enter your community they should feel welcomed, with notes of gratitude and a resources list on how to interact with the community.
Gratify: Instant gratification is really important, if someone builds something with your product help them get a good reach within your community and socials. This would boost their confidence and also motivate other to build with you. Also keep a good resource of stickers/goodies with you, which you can ship to them; this is important because developers love to flex the stacks they've worked on, and would always like to get some "Free Goodies".
Support: Create a very safe environment for developer joining the community. Help them with support tickets, try to be as quick as possible with answers. Take their feedback on product and make them understand your vision. This makes them seek more support from the community and engage in ways you wouldn't have imagined.

Looping DB Example

Looping DB started with greeting messages with showing users different support channels available in the community. They had JS, Python and GoLang support channel differentiated for conversations aligning to those topics. This helped developers go to correct channels.
Looping DB started with fun activities in their community, like discussion elements for recent events in tech. Raffle for community members who're contributing or making something with their product.

Step 4: Make sure you keep 'em coming and avoid dead channels.

The easiest ways to loose your audience is by keeping your channels dead. If you folks even miss a few days with inactivity in your starting phase and you would be loosing interaction with your developers rapidly. To avoid this mistake, keep your communities active with new updates, announcements, creative engagement, quizzes and games.

Step 5: Make it developer first!

Scaling from 1-100 might less difficult then scaling from 100-1000+ because you no longer have to just onboard people new people you also have to maintain the developers already there.
The best way to make sure this happens is, you make the motive of your community developer first and product second. Get more resources available to the community.
- Organize interactive Hackathon/Challenges
- Let community members take the initiatives to manage new activities, give them a stage to make their own following in the community.
- Get famous/influential people joined in your community as mentors or on on your deck. This would make developers want to stay in touch with your community to access resources which are impactful for their career.
- Get a careers page where companies can recruit talented developers from your community
- Last but not least, TRUST in your Developer Community! People who get a lot of knowledge out of your community are going to give back in a lot of ways!

Let me know in comment section about your thoughts on this blog!

Socials

You can connect with me here :)

Twitter: https://twitter.com/SavantNimit
LinkedIn: https://www.linkedin.com/in/nimitsavant
Twitch: https://www.twitch.tv/nimit2801
Website: https://nimitsavant.me

Scratch Newsletter with Appwrite

Nimit Savant — Fri, 15 Mar 2024 18:15:29 +0000

Introduction

Ever wondered how are newsletter systems made for product websites out there? Let's create our own newsletter system where people can come your website and subscribe to your newsletter system. Since we don't want a backend always running in the background it would an amazing idea to implement it with a functions. So let's use the one of the best Cloud Functions services out there, YES Appwrite Function.

I've already drafted an article where I've implemented Appwrite functions with TS.

Let's Start

Let's first create an UI for our website, this can be anything you want to have. I'm just make this so that I can hit on appwrite functions. You can directly skip if you've your UI already implemented.
UI Part
Step 1: I'll be using vitejs vanilla app to get a webpage quickly. You can find this on their website to scaffold an application

yarn create vite my-vue-app --template vanilla

Step 2: Remove all the unnecessary css and js code. I remove counter.js and this is how my other files look like
main.js

import './style.css';

document.querySelector('#app').innerHTML = `
  <div>
    <section>
      <div class="newsletter-box">
        <h2>Scratch Newsletter</h2>
        <form>
          <input type="text" placeholder="Email" />
          <button>Subscribe</button>
        </form>
      </div>
    </section>
  </div>
`

style.css

html {
    background-color: blanchedalmond;
    font-family: 'Courier New', Courier, monospace;
}

.newsletter-box {
    position: absolute;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);
    background-color: #f4f4f4;
    padding: 20px;
    margin: 20px 0;
    border-radius: 5px;
    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}

.newsletter-box h2 {
    margin-bottom: 20px;
}

.newsletter-box button {
    background-color: #ff6600;
    color: white;
    padding: 10px 20px;
    border: none;
    border-radius: 5px;
    cursor: pointer;
}

.newsletter-box button:hover {
    background-color: #ff5500;
}   

.newsletter-box input {
    width: 50%;
    padding: 10px;
    margin-bottom: 10px;
    border: 1px solid #ccc;
    border-radius: 5px;
}

index.html

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Scratch Newsletter</title>
  </head>
  <body>
    <div id="app"></div>
    <script type="module" src="/main.js"></script>
  </body>
</html>

Getting started with Appwrite

Database

Create a collection in your database

Now let's add attributes, we just need the email in our case

Create an API key for your function, this is needed because your function is a basically a backend application which needs access to your database and other appwrite features like accounts, storage and more.

a. Now go to your overview tab and click on Create API key

b. Add permissions just for documents.write. Always keep your permissions to the minimal. This would help you to keep your Appwrite function more secure and also give an idea what features you're actually going to use.

c. Copy the API key we're going to use it further to add it in our function settings

Creating functions

There are many ways to create a function in appwrite but I like to use the CLI. So you can do the installation by following the installation on this link
Then go into your project. And scaffold the project with the below command

appwrite init project

appwrite init function ## I've used nodejs 18 for my settings

Once you've installed the project upload it to your appwrite console

appwrite deploy function

Amazing we're half way through, now we will move on to actually add code to your appwrite function.

App password

So basically now that we're using Gmail as our client to send emails, we've to use it's app passwords feature to get a passwords. It's pretty intuitive, you just go to your 2factor auth -> turn it on and scroll below to add app passwords. For more information follow this article

Appwrite Functions Code

Code explaining the main driver function code please comments explaining what is happening in function, I've also added jsdocs for this function so that you can have a level of typing when you're developing the app.

Why is this important?
Well when you're prototyping your function you would want to see in your editor the obvious mistakes so that you won't have to upload multiple times to check for dumb errors which can be sorted in the editor.

Code explanation

Basically here the sendEmail() function helps us creating a connection to our GMAIL SMTP server which we would further use to send emails. We're using app password here that we generated in the above step and would keep that in our .env our further steps. And then our driver code is taking the email from our post call which in-turn first adds the email to our collection that we created in the above steps and then would call the sendEmail(). The call would be triggered from our client app but you can use the Appwrite console to test this out too!

functions/Scratch Newsletter/src/main.js

import { Client, Databases, ID } from 'node-appwrite';
import nodemailer from 'nodemailer';

/**
 * @param {string} toEmail 
 * @returns 
 */
async function sendEmail(toEmail, log) {

  // Create a new transporter
  var transporter = nodemailer.createTransport({
      host: "smtp.gmail.com",
      port: 587,
      secure: false,
      auth: {
          user: 'mnimitsavant@gmail.com',
          pass: process.env.GMAIL_APP_PASSWORD,
      }
  });

  // Send the email object
  var message = {
    from: "mnimitsavant@gmail.com",
    to: toEmail,
    subject: "test email",
    html: "<h1>Welcome to Scratch Newsletter</h1><br /><p>Thank you for signing up with us!</p>",
  };

  // Send the email
  const info = await transporter.sendMail(message);

  // Log the message id
  log(`Message sent ${info.messageId}`);

  return info.messageId;
}

/**
 * @typedef {object} Req
 * @property {string} method
 * @property {JSON} body
 * @property {String} body.email
 * @property {object} query
 */


/**
 * @typedef {object} Res
 * @property {Function} json
 * @property {Function} send
 * @property {Function} empty
 */

/**
 * @param {object} context
 * @param {Req} context.req
 * @param {Res} context.res
 * @param {object} context.log
 * @param {object} context.error
 * 
 */
export default async ({ req, res, log, error }) => {
  // Why not try the Appwrite SDK?
  //

  var headers = {};
  headers['Content-Type'] = 'application/json';
  headers['Access-Control-Allow-Origin'] = '*';
  headers["Access-Control-Allow-Headers"] =  "Content-Type";
  headers['RAccess-Control-Allow-Methods'] = 'RANDOM';

  log('Scratch Newsletter function invoked')
  try {
    // Create connection with Appwrite Client

    // This was important to add because the websites will have cors, so first they'll send a small request to check if the server is accepting the request and then the post call will happen
    if(req.method === 'OPTIONS') {
      log('OPTIONS METHOD')
      return res.send('', 204, headers);
    } else if(req.method === 'POST') {
      log('Request method is POST')

      const client = new Client()
        .setEndpoint('https://cloud.appwrite.io/v1')
        .setProject(process.env.APPWRITE_FUNCTION_PROJECT_ID)
        .setKey(process.env.APPWRITE_API_KEY);


        // Get the request body and parse
        const body = req.body;
        if(!body.email) {
          // Send a response
          log('Email is required')
          return res.send('Email is required', 400, headers);
        }

        // Create a new database instance
        const database = new Databases(client);

        // Create a new document in the database
        const newData = await database.createDocument(process.env.APPWRITE_DATABASE_ID, process.env.APPWRITE_COLLECTION_ID, ID.unique(), {
          email: body.email
        });

        // Log the new data
        log(newData);
        if(newData.$id) {
          // Send new email
          await sendEmail(newData.email, log);

          // Send a response
          return res.send('Subscribed to the newsletter', 201, headers);

        } else {
          // Send a response
          return res.send('Failed to subscribe to the newsletter', 409, headers);
        }
      } else {
        // Send a response when not using POST method
        return res.send('Invalid request method. Please use POST method to subscribe to the newsletter.', 405, headers);
      }

  } catch (err) {
    // Log the error
    error(err.toString());
    return res.send('Some error occurred. Please try again later.');
  }
};

Add secrets to our Appwrite console

Go to out function settings and then go to environment variable section and click on editor and add your respective .env.

Edit our Client App to hit our function

Step 1.We add a function setupSubscribeButton which helps to hit our function.

client app main.js

import './style.css';

const setupSubscribeButton = (element) => {

  console.log('Setting up subscribe button');
  element.addEventListener('submit', async(event) => {
    event.preventDefault();
    const email = event.target.elements.email.value;
    if(email === '' || email === null) {
      alert('Email is required');
      return;
    }
    console.log('Subscribing', email);

    const res = await fetch('https://65f335d0163e397c95de.appwrite.global', {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
      },
      body: JSON.stringify({ 
        email: email
      }),
    });

    console.log('Subscribed', res.status);
  });
}

document.querySelector('#app').innerHTML = `
  <div>
    <section>
      <div class="newsletter-box">
        <h2>Scratch Newsletter</h2>
        <form action="" id="subscribe">
          <input type="text" id="email" name="email" placeholder="Email" />
          <button type="submit" onClick()=>Subscribe</button>
        </form>
      </div>
    </section>
  </div>
`

setupSubscribeButton(document.querySelector('#subscribe'));

Congratulations

nimit2801 / scratch-newsletter

Scract Newsletter

Scratch Newsletter

A newsletter implementation from scratch using Appwrite Function with Js

Tech stack used

Appwrite
Node.js

Architecture

Every time someone adds their email to the newsletter on the static page. The form sends an invocation to the Appwrite function.
This appwrite function then adds the email to the collection in the appwrite database and sends them a welcome email.

Author

Nimit Savant

View on GitHub

Socials

Twitter: https://twitter.com/SavantNimit
LinkedIn: https://www.linkedin.com/in/nimitsavant
Twitch: https://www.twitch.tv/nimit2801
Website: https://nimitsavant.me

More with Appwrite

Nimit Savant

Jun 24 '23

Appwrite Functions with TypeScript

#appwrite #functions #typescript #dxftw

Comments

4 min read

How to learn a new "Technology"?

Nimit Savant — Tue, 20 Feb 2024 22:55:30 +0000

Introduction

Every day amazing technologies like Appwrite, Dyte and 100s of tools like these are arriving in the market. And as developers to always stay at the top, we would want to try them out! This article focuses on getting helping with a general curve to understand these technologies and adapt them as quickly as possible.

The problem

I feel as a developer when we're learning new stack or technology we're always stuck with boiler plates and making the best use case out of them. We always try to implement something new with the boiler plates and miss the initial settings on how they were supposed to be used.

Discussion and Solution

What I've figured after learning through many open source techs is that, we're always stuck in implementing our own thoughts onto the tech. For eg a new library like svelte is introduced, we focus on adding TS features, get routing features and try to add features which we like into that ecosystem. What we don't realize is that the context of that tech stack and the ecosystem is limited. And that we get quickly frustrated when we can't do something with these technologies. Below are few pointers that we've to keep in check while we're taking a step towards them

Keep in check with your expectations: Always make sure, you implement the base boiler plate the technology/tool is implementing and then try to add your own features
Learn to read through Documentation: What I've realized from my own experience, we skip through the boiler plate documentation as if we know it already. But the ecosystem of this tech has its own context and caveats is something we always forget. So let's keep a habit of reading through initial docs quickly.
Keep learning through stack over-flow and blogs: Yes, that is important, ChatGPT and Bard might not have full context of the problem you're solving, and in general it's good practice to learn more about the technology from blogs and stackover-flow discussions then AI learning.
Take smaller steps: No one is here on time limit judging you how fast you can understand a stack and implement it, start small; learn about the boiler plate. Read though config files and caveats of the stack. And then slowly add your flavor to this. Once you know the more about the ecosystem, have interacted with the community; you can start adding advanced and complex features you would want.
Always make sure to Document: When trying out new stack there would be instances, where you'd not be able to resolve something the traditional way, draft a small blog about the solution that you found. This is going to help both beginners like you who're trying the technology and you when in future you come back to the technology facing the same problem(happened to me 100s of times when I want to initialize a node project with ts)

Conclusion

Go incremental with your project, learn more about the ecosystem. Write about the problems you faced. Manage your expectations and apply advanced features slowly.

Let me know in the comment section your thoughts on this topic!

Why am I getting $parent in keys?

Nimit Savant — Thu, 28 Dec 2023 03:26:46 +0000

Background

While traversing through a mongoose object, you might get a properties like $_parent, $_schema and $_path. Which are added to an object by Mongoose package for its own internal use or maybe future use by us.

Problem

When you're trying, to traverse through an object which is mongoose object, you'll get these keys which are not expected from you. But you still get them! And in your code you don't know where they're coming from.

Solution

To avoid these properties, you can just use a simple toObject() method to this mongoose object and you'd find that to be a normal Object. Without the hidden properties.

Why I wrote this article

There were no solutions for this silly problem that I was looking on the internet, at last I asked this to co-pilot and it responded me with this hint.

Appwrite Functions with TypeScript

Nimit Savant — Sat, 24 Jun 2023 03:30:00 +0000

What are we covering in this article?

Introduction to Appwrite functions
Why would you want to use TS with Appwrite functions
How to initialize a NodeJs function
How to use integrate with typescript

Introduction to Appwrite functions

Appwrite functions are amazing serverless functions introduced by Appwrite used to run in the Appwrite environment on the appwrite cloud or in your self-hosted environment. More on Appwrite Functions could be found here

Why would you want to use TS with Appwrite functions

Personally some developers working with other libraries would want to have types integrated in their functions, and that won't be possible in the js version.
Also this type checking would really allow the developers to find any silly bugs at compilation time. Because when you're making functions you'd want to upload the functions lesser number of times because it's tedious to debug in runtime in general. And this would really save some silly bugs that you might be doing.
While writing complex logic for your backend you would want to have a robust type checking not just for the code interacting with your Appwrite but also the external ones.

How to initialize a NodeJs function

Pre-requisites

You need an account on their beta cloud platform
Create a new project
Get Project ID from the Appwrite Console
Setup Appwrite CLI in your local desktop, for more information refer the docs here
Let's start coding :)

How to use integrate with typescript

Create a folder for your functions
```
mkdir Appwrite Functions
```
Init function

Please initialize your project if you haven't already with appwrite project init before appwrite function init
```
appwrite init function
```

Steps to configure from Node.js to Node.js(TS)

a. Go into the directory

cd functions/Appwrite Function TS

b. Add tsconfig.json file

{
  "compilerOptions": {
   "target": "es5",                          
   "module": "commonjs",                    
   "lib": ["es6"],                     
   "allowJs": true,
   "outDir": "build",                          
   "rootDir": "src",
   "strict": true,         
   "noImplicitAny": true,
   "esModuleInterop": true,
   "resolveJsonModule": true
 }
}

c. Add @types/node and typescript in devDependencies in package.json and a build step in script

typescript: For transpiling ts to js code in build folder
@types/node: For getting node types in ts

"scripts": {
"build": "tsc src/index.ts  --outDir build"
},
...
"devDependencies": {
"@types/node": "^18.16.3",
"typescript": "^5.0.4"
}

d. Install all the packages

yarn #or npm install

e. Create a new file in /src and called index.ts and copy content from index.js and feel free to delete the index.js file or keep feel free to keep it for future reference. At this point your folder structure should look like this

f. Make changes to your index.ts to make it ts compatible, your final code should look like this in index.ts

You'd also need an API for your function to have access to your Appwrite environment, you might have this question so as to why is that so, Appwrite functions are part of the Appwrite environment. Well I had the same doubt and Appwrite team working on this.
This is important for two reasons

We don't know what permission the Appwrite function might need so its better to specify an API key with perfect perms

Appwrite function is in general really a backend server only using node-appwrite sdk which in turn needs API key for its working.

import * as sdk from 'node-appwrite';
/*
'req' variable has:
'headers' - object with request headers
'payload' - request body data as a string
'variables' - object with function variables
'res' variable has:
'send(text, status)' - function to return text response. Status code defaults to 200
'json(obj, status)' - function to return JSON response. Status code defaults to 200
If an error is thrown, a response with code 500 will be returned.
*/
module.exports = async function (req: any, res: any) {
const client = new sdk.Client();
if (
!req.variables['APPWRITE_FUNCTION_ENDPOINT'] ||
!req.variables['APPWRITE_FUNCTION_API_KEY']
) {
console.warn(
  'Environment variables are not set. Function cannot use Appwrite SDK.'
);
} else {
client
  .setEndpoint(req.variables['APPWRITE_FUNCTION_ENDPOINT'])
  .setProject(req.variables['APPWRITE_FUNCTION_PROJECT_ID'])
  .setKey(req.variables['APPWRITE_FUNCTION_API_KEY'])
  .setSelfSigned(true);
}
res.json({
areDevelopersAwesome: true,
});
};

g. Go one folder up to Appwrite Functions TS Folder where we initialized our code and edit appwrite.json. Change the entry point from src/index.js -> build/index.js

This basically helps to point at the transpiled ts code in build folder

...
"entrypoint": "build/index.js",
...

h. Run the deploy command and stay in the same folder you created called Appwrite Function TS

🎊 Congratulations your ts function is made, now let's run the deploy command to upload this function on Appwrite cloud/self-hosted cloud

appwrite deploy function

Your response should look similar to this

Let's configure Appwrite Function on Console
a. Now let's configure the Appwrite Function in the web console and add APPWRITE_FUNCTION_API_KEY & APPWRITE_FUNCTION_ENDPOINT

b. Now we will run the function from the console!

c. Goto Executions in your function and check for the latest output

You can find the GitHub code for the above Article here

nimit2801 / Appwrite-Function-TS

This repo helps as a boiler plate to build appwrite functions with ts

Credits

Credits to the graphic designer who made this cover for me

Socials where we can connect

Discord Server: Last Friday's Thing
Twitter: SavantNimit
Instagram: nimit_savant
LinkedIn: nimitsavant
Website: Personal Website

Lets make your first Discord Bot!

Nimit Savant — Wed, 04 Aug 2021 17:03:48 +0000

Introduction:

Discord bots are fun to make because you can experiment with a lot of new things there. You're given a platform "Discord" and you integrate with almost all the tools available out there.

Let's start with the Prerequisites:

Node.js and npm installed in mac/windows
Create a new directory name it "pokemon-discordo" or anything you like :D
```
  npm init -y
```
Open your cli/terminal/cmd we're installing three dependencies:
- Discord.js for using discords API with Nodejs. This will help us to code our bot.
- dotenv is a package we use to store our tokens and API keys so that we don't accidentally share them on GitHub. **node-fetch* a light-weight module that brings window.fetch to Node.js
```
  npm install discord.js dotenv node-fetch
```
We'll also use nodemon, which helps you to load your changes continuously with changes in your files eg: JavaScript, JSON, Html/CSS, etc except ".env".
```
  npm i -g nodemon
```

Let's Start Coding

Create a new js file "bot.js" and include all the libraries in it.

    const Discord = require('discord.js');
    require('dotenv').config();
    const fetch = require('node-fetch');

Now let's declare our URL for the API and our bot object, in discord.js we have a way to do things if you want to include something you can include the class declared in the lib
```
  const URL = 'https://pokeapi.co/api/v2/pokemon';
  const bot = new Discord.Client();
```

Discord.Client class has a lot of event listeners we are going to use "ready" and "message" in our bot.

  bot.on('ready', () => {
      console.log('Bot is up and running!');
  });

  bot.on('message', async (message) => {
  // some code
  })

Let's add some code in our 'message' event listener, so essentially we want to listen to messages, and as soon as a message is starting with "pokemon" FYI(this message we're listening to is from a user who is using the bot on a server or directly talking to the bot).

  bot.on('message', async (message) => {
      if (message.content.startsWith('pokemon')) {
          const messageArray = message.content.split(' ');
          const result = await fetch(URL +     `/${messageArray[1]}`);
          const data = await result.json();
          const helpEmbedd = new Discord.MessageEmbed()
          .setTitle(`Name: ${data.name}`)
            .setImage(`${data.sprites.front_default}`);
          message.reply(helpEmbedd);
      }
  });

In the above code:
a. We're taking the string after pokemon for eg: pokemon Pikachu, the above code will send this name Pikachu to pokemon API and send back its information in response.
b. Further, the code will take out front_default from the response provided by pokemon API.
c. And this response is sent in message.embed form message.channel.send to the channel where the data was requested for.

Let's now add our code to our bot token:

a. Go to https://discord.com/developers/applications

b. Open your newly created application

c. Click on BOT

d. Click on create your bot

e. Get your TOKEN :D
Create a new file ".env" and paste your bot token

BOT_TOKEN=<--YOUR BOT TOKEN-->

f. In your bot.js file

bot.login(`${process.env.BOT_TOKEN}`);

Full bot.js Code:

require('dotenv').config();
const fetch = require('node-fetch');
const Discord = require('discord.js');

const URL = 'https://pokeapi.co/api/v2/pokemon';

const bot = new Discord.Client();

bot.on('ready', () => {
    console.log('Bot is up and running!');
});

bot.on('message', async (message) => {
    if (message.content.startsWith('pokemon')) {
        const messageArray = message.content.split(' ');
        const result = await fetch(URL + `/${messageArray[1]}`);
        const data = await result.json();
        const helpEmbedd = new Discord.MessageEmbed()
            .setTitle(`Name: ${data.name}`)
            .setImage(`${data.sprites.front_default}`);
        message.reply(helpEmbedd);
    }
});

bot.login(`${process.env.BOT_TOKEN}`);

Our Pokemons are here

Full Repo

harshil1712 / pokemon-discord-bot

Pokemon Discord Bot

Introduction

Learn to build a Discord bot using Discord.js. This repository will help you get started with building a Discord bot that fetches data from the Pokemon API.

The bot listens to the command pokemon and fetches the infromation of the Pokemon specified after the command.

Installation

1. Clone the Repository

git clone https://github.com/harshil1712/pokemon-discord-bot.git

2. Install Packages

yarn install

npm install

3. Create a `.env` file in the root directory of the project.

4. Paste the following in the `.env` file and add you bot token.

BOT_TOKEN=<--YOUR BOT TOKEN-->

5. Start the Bot

yarn start

npm start

Make sure to add your bot to a server or open a direct message with it, to test the functionalities.

Learn more

We created this bot on a Twitch live stream! If you want to learn from the start you can checkout the…

View on GitHub

The Recording for the Twitch Live is available: Youtube

PS: Add your bot to your server and ask your friends to suggest some cute Pokemon :D

Socials of some wonderful people:

Follow me on twitter.com/SavantNimit
Hey! Harshil Thanks for the amazing live stream invite 💖
Follow Harshil on: twitch.tv/harshil1712 twitter.com/harshil1712 dev.to/harshil1712
Thanks Ashwin for the wonderful poster design ✨
Follow Ashwin on instagram.com/ashwin.adiga behance/ashwinadiga
Thanks Harsh(ObitoDarky) 👾 for all the awesome suggestions and guidance for writing this blog
Follow @obitodarky on twitter/obitodarky

DEV Community: Nimit Savant

Why Developer Advocacy Matters in India: A Guide for Aspiring Advocates

Inception

What is Developer Advocacy?

Why is Developer Advocacy Important in India?

How can you start contributing to the ecosystem of Developer Advocacy or become one?

Learning Pathways to Become a Developer Advocate

Conclusion

How to build your first Tech Community?

Background

Introduction

Dive In

Socials

Scratch Newsletter with Appwrite

Let's Start

Getting started with Appwrite

Database

Creating functions

App password

Appwrite Functions Code

Add secrets to our Appwrite console

Edit our Client App to hit our function

Congratulations

nimit2801 / scratch-newsletter

Scract Newsletter

Scratch Newsletter

Tech stack used

Architecture

Author

Socials

Appwrite Functions with TypeScript

How to learn a new "Technology"?

Introduction

The problem

Discussion and Solution

Conclusion

Why am I getting $parent in keys?

Background

Problem

Solution

Why I wrote this article

Appwrite Functions with TypeScript

What are we covering in this article?

Introduction to Appwrite functions

Why would you want to use TS with Appwrite functions

How to initialize a NodeJs function

How to use integrate with typescript

nimit2801 / Appwrite-Function-TS

This repo helps as a boiler plate to build appwrite functions with ts

Credits

Socials where we can connect

Lets make your first Discord Bot!

Introduction:

Let's start with the Prerequisites:

Let's Start Coding

harshil1712 / pokemon-discord-bot

Pokemon Discord Bot

Introduction

Installation

1. Clone the Repository

2. Install Packages

3. Create a .env file in the root directory of the project.

4. Paste the following in the .env file and add you bot token.

5. Start the Bot

Learn more

3. Create a `.env` file in the root directory of the project.

4. Paste the following in the `.env` file and add you bot token.