In 2025, multi-agent systems have finally become accessible to individual developers and small teams. One of the most promising new platforms is Strands — an open-source framework from AWS that lets you compose autonomous agents into reliable, production-ready workflows using just Python.

Strands stands out because:

• It is fully open-source (Apache 2.0)
• Works seamlessly with Bedrock, Anthropic Claude, OpenAI, Grok, or any local LLM
• Supports sequential, parallel, and hierarchical agent orchestration
• Has built-in memory, tool use, retries, and human-in-the-loop
• Deploys as a simple FastAPI server or serverless on AWS Lambda

Official repository & documentation: https://github.com/strands-agents

Quick-start SDK:

pip install strands-agents

Below are three practical, India-centric use cases I built recently using Strands. Each one is deliberately simple enough to run on a laptop, yet powerful enough to solve real problems faced by students, small businesses, and policy enthusiasts.

Use Case 1: Personalized IIT/NIT Branch Recommender for JEE Aspirants

Every year ~15 lakh students appear for JEE Main. Deciding which branch and institute to choose based on rank, interest, and job market is overwhelming.
This 3-agent workflow helps:

1. Profile Analyzer → matches rank against historical cutoffs
2. Market Insights → pulls current demand for that branch (Naukri/LinkedIn trends)
3. Planner → gives scored recommendations + preparation roadmap

# Full working code: https://github.com/yourusername/strands-iit-recommender
from strands import Agent, Workflow
import pandas as pd

iit_cutoffs = pd.read_csv("iit_nit_cutoffs_2025.csv")  # You can host your own

@Agent(name="profile_analyzer")
def analyze_profile(input_data):
    rank = input_data["jee_rank"]
    eligible = iit_cutoffs[iit_cutoffs["closing_rank"] >= rank]
    return {"eligible": eligible.to_dict("records")}

@Agent(name="market_trends")
def get_trends(eligible):
    # In real version use Naukri or LinkedIn API
    trends = {"CSE": 0.95, "AI": 0.92, "Mechanical": 0.65, "Civil": 0.55}
    for item in eligible["eligible"]:
        item["demand_score"] = trends.get(item["branch"], 0.5)
    return eligible

@Agent(name="recommender")
def final_recommendation(data):
    for item in data["eligible"]:
        item["total_score"] = 0.6 * (1 - item["closing_rank"]/100000) + 0.4 * item["demand_score"]
    top5 = sorted(data["eligible"], key=lambda x: x["total_score"], reverse=True)[:5]
    return {"recommendations": top5}

workflow = Workflow(agents=[analyze_profile, get_trends, final_recommendation])
result = workflow.run({"jee_rank": 8421, "category": "General"})

Perfect for coaching institutes or career-counselling startups.

Use Case 2: Automated GST Compliance Checker for Indian MSMEs

1.4 crore+ GST registrants in India file returns every month. Even a single wrong HSN code or rate can trigger notices.
This lightweight checker parses invoices (CSV/PDF), validates HSN & tax rates against the official GST database, and flags discrepancies — all in <2 seconds per 100 invoices.

# Full code: https://github.com/yourusername/strands-gst-checker
from strands import Agent, Workflow
import pandas as pd

@Agent(name="invoice_parser")
def parse(input_file):
    df = pd.read_csv(input_file)  # or use PyPDF2/pdfplumber for PDF
    return {"items": df.to_dict("records")}

@Agent(name="hsn_validator")
def validate_hsn(items):
    valid_rates = {"8471": 18, "6109": 12, "1006": 0}  # In production call GST API
    for item in items["items"]:
        expected = valid_rates.get(str(item["hsn_code"]), 18)
        item["correct_rate"] = expected
        item["error"] = item["applied_rate"] != expected
    return items

@Agent(name="reporter")
def generate_report(validated):
    errors = [i for i in validated["items"] if i["error"]]
    return {"total_errors": len(errors), "flagged_items": errors, "ready_to_file": len(errors)==0}

workflow = Workflow(agents=[parse, validate_hsn, reporter])
result = workflow.run("april_invoices.csv")

Many CA firms and SaaS billing platforms can ship this tomorrow.

Use Case 3: NEP 2020 & Engineering Education Policy Impact Tracker

With NEP pushing multidisciplinary education, AI minors, and flexible curricula, educators and journalists need quick sentiment + impact analysis of new policies.
This agent trio scrapes recent discussions (X, government portals, news), runs sentiment analysis, and simulates possible outcomes.

# Full code: https://github.com/yourusername/strands-nep-tracker
from strands import Agent, Workflow
from textblob import TextBlob

@Agent(name="scraper")
def fetch_discussions(topic="NEP 2020 engineering reforms"):
    # In real version use X API or RSS feeds
    sample_posts = [
        "Finally IITs offering humanities with CSE – great move!",
        "NEP ignores rural engineering colleges completely",
        "New AI degree at IIT Madras is game changing"
    ]
    return {"posts": sample_posts}

@Agent(name="sentiment")
def analyze(posts):
    scores = [TextBlob(p).sentiment.polarity for p in posts["posts"]]
    return {"avg_sentiment": sum(scores)/len(scores), "details": scores}

@Agent(name="impact")
def predict(sentiment_data):
    if sentiment_data["avg_sentiment"] > 0.15:
        return {"prediction": "+12-18% enrollment in new-age branches", "confidence": "High"}
    else:
        return {"prediction": "Implementation challenges ahead", "confidence": "Medium"}

workflow = Workflow(agents=[fetch_discussions, analyze, predict])
result = workflow.run()

Great for think-tanks, journalists, or university administration dashboards.

Why Strands Feels Like the Future

In all three projects I never wrote a single line of complex state management, retry logic, or prompt-chaining boilerplate — Strands handles it natively. Deploying the GST checker to a public API took exactly 8 lines:

from strands.server import serve
serve(workflow, port=8000)

If you are an developer tired of LangChain’s complexity or AutoGen’s academic feel, give Strands a weekend. You’ll be surprised how quickly real-world problems turn into production workflows.
Start here → https://github.com/strands-agents
Happy building!

Ever wondered how to keep your Facebook page active with fresh AI-generated content — without lifting a finger? This tutorial will walk you through setting up a serverless system to automatically generate images using OpenAI’s DALL·E and post them to a Facebook Page, all triggered daily based on entries in a DynamoDB table.

What You’ll Build

A Node.js-based AWS Lambda function that:

1. Scans DynamoDB for today’s scheduled content,
2. Generates an image using OpenAI’s DALL·E API,
3. Uploads the image to your Facebook Page using the Facebook Graph API.

Let’s get to work.

Prerequisites

AWS Account with:

• DynamoDB table (e.g., autopost)
• IAM role with Lambda + DynamoDB permissions

Facebook Developer Account

• Facebook Page & App set up
• pages_read_engagement, pages_manage_posts permissions

OpenAI API Key with DALL·E access

Node.js + AWS SDK

Serverless Framework (optional but ideal)

DynamoDB Table Setup

Create a DynamoDB table named autopost with at least these fields:

Facebook Page Access Token

To post to a page, you need a Page Access Token. Here’s how:

• Go to Facebook Graph API Explorer
• Select your app, generate a User Token with the pages_manage_posts permission
• Use that token to retrieve a long-lived Page Access Token:

Note: The token you get for your page is "permanent" until manually revoked.

Generate Image with OpenAI

Install OpenAI SDK:

npm install openai

Generate an image like this:

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const image = await openai.images.generate({
  model: 'dall-e-3',
  prompt: 'A futuristic city skyline at sunset',
  n: 1,
  size: '1024x1024',
});
const imageUrl = image.data[0].url;

Post Image to Facebook Page

Use the Facebook Graph API to post:

const endpoint = `https://graph.facebook.com/v22.0/${PAGE_ID}/photos`;
const params = {
  url: imageUrl,
  access_token: pageAccessToken,
};

await axios.post(endpoint, null, { params });

Full Serverless Function (Node.js)

Here’s the complete code broken down:

main.js

const axios = require('axios');
const { OpenAI } = require("openai");
const moment = require('moment'); 
const AWS = require('aws-sdk');
const mydocumentClient = new AWS.DynamoDB.DocumentClient();

const PAGE_ID = process.env.PAGE_ID;
const ACCESS_TOKEN = process.env.ACCESS_TOKEN;
const OPENAI_API_KEY = process.env.OPENAI_API_KEY;

const openai = new OpenAI({ apiKey: OPENAI_API_KEY });

async function getUserId(userAccessToken) {
  const response = await axios.get(`https://graph.facebook.com/v22.0/me?access_token=${userAccessToken}`);
  return response.data.id;
}

async function getPermanentPageToken() {
  const userId = await getUserId(ACCESS_TOKEN);
  const pageToken = await axios.get(`https://graph.facebook.com/v22.0/${userId}/accounts?access_token=${ACCESS_TOKEN}`);
  return pageToken.data.data[0].access_token;
}

async function generateImageWithOpenAI(prompt) {
  const image = await openai.images.generate({ model: 'dall-e-3', prompt, n: 1, size: "1024x1024" });
  return image.data[0].url;
}

async function postImageToPage(imageUrl, message) {
  const token = await getPermanentPageToken();
  const endpoint = `https://graph.facebook.com/v22.0/${PAGE_ID}/photos`;
  await axios.post(endpoint, null, {
    params: {
      url: imageUrl,
      access_token: token,
      caption: message,
    }
  });
}

async function main(prompt) {
  const imageUrl = await generateImageWithOpenAI(prompt);
  await postImageToPage(imageUrl, `Image Generated Using OpenAI`);
}

module.exports.run = async (event, context) => {
  const time = new Date();
  const params = {
    TableName : 'autopost',
    FilterExpression: 'postdate = :pdate',
    ExpressionAttributeValues: { ":pdate": moment(time).format('MM/DD/YYYY') },
  };
  const data = await mydocumentClient.scan(params).promise();

  if (data.Items[0]?.posttype === 'quote') {
    await main(data.Items[0].post);
  }

  console.log(`Function "${context.functionName}" executed at ${time}`);
};

Deploy with Serverless Framework

serverless.yml

service: autopost-facebook

provider:
  name: aws
  runtime: nodejs18.x
  environment:
    PAGE_ID: YOUR_PAGE_ID
    ACCESS_TOKEN: YOUR_USER_ACCESS_TOKEN
    OPENAI_API_KEY: YOUR_OPENAI_API_KEY
  region: ap-south-1

functions:
  autopost:
    handler: main.run
    events:
      - schedule: cron(0 5 * * ? *)  # 5 AM UTC daily

Results

You now have a fully automated social media poster that:

• Reads a scheduled post from DynamoDB
• Uses OpenAI to generate relevant imagery
• Uploads the result to your Facebook Page

Perfect for businesses, content creators, or community pages that want a low-maintenance, high-impact presence!

Final Thoughts

This project is a glimpse into how serverless architecture + generative AI can automate content generation and delivery. You could easily extend it to:

• Post to Twitter, Instagram, or LinkedIn
• Generate text captions using GPT
• Add approval workflows or audit trails

Let’s face it—in the whirlwind world of generative AI (Gen AI), the conversation around “prompt engineering” can sometimes feel a bit like trying to reinvent the wheel. I remember not too long ago, I was just as baffled as many others, wondering how simply asking questions could ever be called “engineering.” But here’s the scoop: there’s a method to this madness, and it turns out, managing prompts is as critical as guarding the crown jewels in any enterprise setting.

Prompts: The New Crown Jewels

Think of prompts as the secret sauce that makes your AI-powered apps stand out. Just like companies fiercely protect their code repositories with all sorts of high-tech security measures, the prompts you craft are valuable intellectual property. An Enterprise Prompt Repository isn’t just about safeguarding these treasures; it’s about creating a single, well-organized hub where every carefully tuned prompt can be stored, versioned, and accessed by the right team members—kind of like having a digital vault for your genius ideas.

When building AI applications, it’s easy to overlook the magic behind the curtain. Sure, the model is what drives the engine, but it’s the finely crafted prompts that really make everything hum. The time, creativity, and resources you pour into designing, validating, and refining these prompts are no small feat—they’re the secret ingredient that can make or break your AI solution. So, setting up a dedicated repository isn't just a neat-to-have; it’s a strategic investment in your future success.

The Building Blocks of Enterprise RAG

In today’s digital landscape, the art of prompt creation is taking center stage as companies tap into strategies like Retrieval-Augmented Generation (RAG). Picture this: when you’re integrating off-the-shelf systems like Salesforce or ServiceNow, you need prompts that are tailor-made for your industry. A prompt that shines when assessing customer sentiment in hospitality might need a complete makeover to work for financial services. The beauty of an Enterprise Prompt Repository is that it offers a centralized platform to manage these diverse, domain-specific prompts, ensuring they align with your organizational goals—and maybe even surprise you with a spark of brilliance now and then.

Keeping Your AI on Its Toes: Evaluation Pipelines

One of the key components of a successful Gen AI architecture is the continuous evaluation of prompts against evolving models. In cloud-managed AI environments—such as those offered by AWS Bedrock—establishing an automated evaluation pipeline is crucial.

Now, let’s talk about keeping things fresh. AI models are continuously evolving, so why should your prompts be any different? Imagine having a rigorous evaluation pipeline that tirelessly tests your prompts against every shiny new model that hits the market. This isn’t just about staying current; it’s about setting up an early-warning system that alerts you when a new model might outperform your current setup. By continuously benchmarking against a “golden copy” of your best data, your prompts—and models—get to keep evolving, ensuring your downstream systems always have a reason to cheer.

A Future Filled with Opportunities

The demand for clever prompt management tools is only going to grow as more enterprises venture into AI. Sure, there might be some solutions out there that scratch the surface, but imagine the impact of a platform built specifically to address all your prompt repository needs. Whether you’re a seasoned tech giant or a nimble startup, investing in this area could not only streamline your AI efforts but also give you a competitive edge. Who wouldn’t want a neatly organized library of prompts that are as polished and innovative as the apps they power?

In this fast-paced era of AI innovation, managing your prompts isn’t just another task on the checklist—it’s the heart of your Gen AI engine. An Enterprise Prompt Repository ensures your most valuable ideas are protected, organized, and always ready to be deployed when that next big opportunity knocks. By investing in structured prompt management and a robust evaluation pipeline, you’re not just keeping up with the times; you’re positioning yourself at the forefront of a technological revolution. And let's be honest—having a little fun while doing it never hurts.

This is especially applicable to those who are photographers, graphic artists, etc. This may not be applicable to those commenting on current affairs and other such scenarios where it is mostly about responding to an existing tweet/post. This article uses AWS S3, AWS DynamoDB & AWS Lambda.

If you are a photographer or graphic artist, it is about tweeting/posting regularly to actively engage your existing followers and attract new ones.

This is what we are going to do

• Create AWS S3 bucket and upload all the pictures
• Create AWS DynamoDB table with the posting schedule
• Create an app on the Twitter developer and get the keys
• write code to pick the picture as per the schedule and post it on Twitter

S3 Bucket

Create AWS S3 bucket and upload all the images to the bucket and set permissions such that your Lambda code can access those images.

Create a Table in AWS DynamoDB

Create a DynamoDB table with columns as shown in the screenshot below. You are free to add more columns as necessary. I included a post-type column to differentiate posting images from pictures.

Twitter Developer Part

You will need to create an application on the Twitter Developer portal. Make sure the app has full permissions to read, write and direct messages. Please verify this on your Twitter account settings. Look for connected apps and make sure it has all the permission you set on the developer portal.

...and the AWS Lambda NodeJS Code

As you can see in the code, we connect the DynamoDB table and pull the posts as per the date before posting them on Twitter based on if it is a picture or text.

'use strict';

const moment = require('moment'); 
const AWS = require('aws-sdk');
const mydocumentClient = new AWS.DynamoDB.DocumentClient();

const BUCKET_NAME = <s3 bucket name>;
const IAM_USER_KEY = <IAM User key>;
const IAM_USER_SECRET = <IAM User Secret>;

const s3bucket = new AWS.S3({
  accessKeyId: IAM_USER_KEY,
  secretAccessKey: IAM_USER_SECRET
});

const Twit = require('twit')

const T = new Twit({
  consumer_key:         <Twitter Consumer key>,
  consumer_secret:      <Twitter Consumer secret>,
  access_token:         <Twitter Access Token>,
  access_token_secret:  <Twitter Access Token secret>,
})

module.exports.run = async (event, context) => {
  const time = new Date();
  const params = {
    TableName : <DynamoDB Table name>,
    FilterExpression: 'postdate = :pdate',
    ExpressionAttributeValues: {":pdate": moment(time).format('MM/DD/YYYY')},
  };
  const data = await mydocumentClient.scan(params).promise();
  console.log('data', data.Items[0].post);
  if (data.Items[0].posttype=='quote') {
    const tweet = await postTweet(data.Items[0].post);
    console.log('tweet', tweet);
  } else {
    const tweet = await postpic(data.Items[0].post);
    console.log('tweet', tweet);
  }

  console.log(`Your cron function "${context.functionName}" ran at ${time}`);
};

const postTweet = (post) => {
  return new Promise ((resolve, reject) => {
    T.post('statuses/update', { status: post }, function(err, data, response) {
      if (err) {
        reject(err);
      }
      resolve(data);
    })
  })
}

const postpic = async (post) => {
  const data = await s3bucket.getObject({
    Bucket: BUCKET_NAME,
    Key: post
  }).promise()
  return new Promise ((resolve, reject) => {
    if (data != null) {
    T.post('media/upload', { media_data: Buffer.from(data.Body).toString('base64') }, function (err, data, response) {
      console.log('err', err);
      console.log('data1', data);
      var mediaIdStr = data.media_id_string
      var altText = "flowers" //if you are posting pictures of flowers
      var meta_params = { media_id: mediaIdStr, alt_text: { text: altText } }
     
      T.post('media/metadata/create', meta_params, function (err, data, response) {
        if (!err) {

          var params = { status: <Text with picture>, media_ids: [mediaIdStr] }
     
          T.post('statuses/update', params, function (err, data, response) {
            console.log(data)
            resolve(data)
          })
        }
      })
    })
  }

  })
}

Scheduling your Lambda

Finally, it is time to set your Lambda to run by itself at the scheduled hour. Read more about scheduling expressions in lambda here.

This article is a simple guide to mint an NFT on the Opensea & Rarible. If you are an independent content creator, like a photographer, sketch artist, painter, graphic designer etc and if you would like to start listing your content in the NFT market place like Opensea or Rarible then this article is for you.

To start with, you would need an ethereum account which you can acquire with the help of one of the numerous wallet programs. I am going to use Metamask for this article. You can install the Metamask add-on for Chrome browser from the Chrome Web Store.

To mint an NFT we need to have some crypto currency called ethereum. We would explore how we can mint an NFT without paying for Gas. Gas refers to the unit that measures the amount of computational effort required to execute specific operations on the Ethereum network.

Once you are through on Opensea sign-in, you would click on the create button to mint an NFT using the picture or art work that you may have.

To mint an NFT on Opensea directly using ethereum you will need ethereum coins in your ethereum account to pay as gas without which you cannot mint.

Alternatively, in Rarible, you have an option of letting the buyer to pay the gas fee. So, if you want to directly mint an NFT in ethereum without any ethereum balance then you should head to rarible.

Once you are in the new NFT creation form of opensea or rarible, filling it pretty straight forward.

Once you upload the image and fill the relevant information for the submission, NFT will be created but it will not be in 'Sell' mode. You will need to click on the 'Sell' button on the top right corner to place the NFT in the sell mode.

As explained before, in case of rarible, you don't need have any ethereum balance and select the option (default) of allowing them collect the gas from the eventual buyer.

This was just an intro into the minting an NFT for someone who doesn't understand the technology behind it but would love convert their creations into NFT. You can read help documents from both Opensea and Rarible to understand more features.

Happy Minting!!

It is the season of NFTs and DeFi. In case you have been living under a rock then you need read more about NFTs and DeFi using the following links.

• Non-fungible tokens (NFT)
• Decentralized finance (DeFi)

Now that you understand the terms, let us understand how NFTs are minted. NFT market is definitely moving from a few minters to tools & techniques for content creators to mint NFTs on their own.

The following are the key steps in minting a NFT.

1. You need the image / art work / clip to be uploaded to IPFS. You can use any of the IPFS clients that allow you to upload the asset and pin it which will make the asset available for any one to access it through a link. I am using Pinata Cloud for IPFS.
2. You need some test ethers on your Metamask Wallet. Once you installed Metamask Google Extension, load test ethers using the Rinkeby faucet. Also, load some LINK on your Rinkeby testnet address.

I built these APIs on top of an existing repo by Patrick Collins. Check out the repo in the below GitHub link.

• Chainlink Random Character Creation

The above example deals with minting a collection of 'Dungeons and Dragons' to Rinkeby. It has the following key steps.

Step 1:

truffle migrate --reset --network rinkeby

Step 2:

truffle exec scripts/fund-contract.js --network rinkeby

Step 3:

truffle exec scripts/generate-character.js --network rinkeby

Step 4:

truffle exec scripts/get-character.js --network rinkeby

Step 5:

truffle exec scripts/set-token-uri.js --network rinkeby

Steps 1 & 2 deal with setting up Rinkeby connection and migrating the contracts related to NFT creation to Rinkeby Testnet. Steps 3, 4 & 5 include executing appropriate functions on the migrated contracts to randomly select characters and setting up metadata URI for the minted NFT. Please go through the README.md of the above repo to understand other set up details.

The idea is to build a NodeJS application that will use the above discussed steps. We can a user Node's Child Process to execute truffle commands on the CLI. Below is an example of wrapping up the first step in the Child Process call.

app.get('/pushcontract', async(req, res) => {
  try {
    const child = await spawn1('truffle migrate --reset --network rinkeby', [], {shell: true});
    console.log(child.toString());
    res.send('Migrate contracts');
  } catch (e) {
    console.log(e.stderr.toString())
  }
})

Just like above sample, we can create code to execute the remaining steps mentioned above to complete the minting process. Prior to executing these steps, we need to create the required contract and migrate it to Rinkeby testnet.

We can also create contract needed for minting the NFT using file manipulation in NodeJS. We make changes to the 'template' contract on the fly using NodeJS fs library and then execute the truffle commands to migrate the contracts.

app.post('/createcontract', async(req, res) => {

    console.log('filename', req.body.filename);
    files = fs.readdirSync('./contracts');
    console.log(files);
    files.forEach(file => {
            const fileDir = path.join('./contracts/', file);
            console.log(fileDir);
            if (file !== 'Migrations.sol') {
              try {
                fs.unlinkSync(fileDir);
              } catch (error) {
                console.log(error);
              }
  
            }
    })
    fs.copyFileSync('sample.sol', './contracts/' + req.body.filename + '.sol');
    const data = fs.readFileSync('./contracts/' + req.body.filename + '.sol', 'utf8');
    let result = data.replace(/DungeonsAndDragonsCharacter/g,  req.body.filename);
    fs.writeFileSync('./contracts/' + req.body.filename + '.sol', result, 'utf8');
    
    fs.unlinkSync('./migrations/2_mycontract_migration.js');
    fs.copyFileSync('2_mycontract_migration_backup.js', './migrations/2_mycontract_migration.js');
    const data1 = fs.readFileSync('./migrations/2_mycontract_migration.js', 'utf8');
    let result1 = data1.replace(/DungeonsAndDragonsCharacter/g,  req.body.filename);
    fs.writeFileSync('./migrations/2_mycontract_migration.js', result1, 'utf8');
    res.send('created contract');

})

In the above code block, we are copying sample.sol to contracts folder after deleting all the other existing contracts from the contracts folder. After copying sample.sol to contracts folder with desired name, we selectively replace contents of the newly created contract based on the request received in the express API call. The NFTs minted through the above process can be viewed on the opensea Rinkeby testnet gallery.

As discussed above, before we get ready with minting, we need to pin the image / art work to IPFS. We can build APIs for uploading and pinning the image to IPFS using Pinata, there are other ways as well. Please go through their docs to identify the APIs for uploading and pinning the image. Once the image is successfully uploaded Pinata APIs return CID which is a unique identifier for the uploaded file / image.

The final URI looks something like above. The 'XXX' is where the unique CID will be. We need to embed the image URI inside metadata JSON file before uploading the JSON file to IPFS. Please go through metadata folder in Dungeon & Dragons GitHub repo for more details on how the metadata JSON file should look like.

app.post('/upload', upload.single('File'),function(req, res) {

    console.log(req.file);
        
    data.append('file', fs.createReadStream(req.file.path));
    data.append('pinataMetadata', '{"name":"' + req.file.filename + '"}');

    var config = {
        method: 'post',
        url: 'https://api.pinata.cloud/pinning/pinFileToIPFS',
        headers: { 
        'Content-Type': 'multipart/form-data', 
        'pinata_api_key': <pinata api key>, 
        'pinata_secret_api_key': <pinata secret key>, 
        ...data.getHeaders()
        },
        data : data
    };

    axios(config)
    .then(function (response) {
    console.log(JSON.stringify(response.data));
    res.send(JSON.stringify(response.data));
    })
    .catch(function (error) {
    console.log(error);
    });

});

Apart from the above, you can also plugin the market place from the opensea using the opensea api. Below is the sample ReactJS code to fetch the NFTs from opensea and display in a NFT Gallery.

import React, {useState, useEffect } from 'react';
import { Container, Row, Col, Card, Button } from 'react-bootstrap';
import Imgix from 'react-imgix';

function MarketPlace() {
    const [isLoading, setIsLoading] = useState(true);
    const [NFTs, setNFTs] = useState([]);

    useEffect(() => {
        setIsLoading(true);
        var requestOptions = {
            method: 'GET',
            redirect: 'follow'
          };
          
          fetch("https://testnets-api.opensea.io/api/v1/assets?owner=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx&offset=0&limit=50", requestOptions)
            .then(response => response.json())
            .then((result) => {
                console.log('Success:', result);
                setIsLoading(false);
                const result1 = result.assets.filter(d => d.image_thumbnail_url !== null)
                setNFTs(result1);
            })
            .catch(error => console.log('error', error));
    }, []);

    if (isLoading) {
        return (
            <section>
                Loading....
            </section>
        )
    }


    return (
        <div style={{ backgroundColor: '#111'}}>
        <Container className='mt-4'>
        <Row>
          {NFTs.map(plan => (
                <Col md={3}>
                  <Card bg="dark" text="white">
                      <div style={{ textAlign: 'center'}}>
                      {/* <Card.Img variant="top" src={plan.image_thumbnail_url} style={{ width: "18rem", height: "20rem" }} /> */}
                      <Imgix src={plan.image_thumbnail_url} sizes="800vw" />;
                      </div>
                      <Card.Body>
                          <Card.Title>{plan.name}</Card.Title>
                          <Card.Text>{plan.description.replace(/^(.{20}[^\s]*).*/, "$1")}</Card.Text>
                          <Button variant="primary" onClick={() => window.open(plan.permalink, "_blank")}>Buy This NFT</Button>
                      </Card.Body>
                  </Card>
                  <Card style={{ backgroundColor: '#111' }}><br></br></Card>
               </Col>   
          ))}
        </Row>
        </Container>
        </div>
      );

}

export default MarketPlace

This approach gives a better understanding of what goes into minting an NFT. This is definitely not a production ready code. For that, we may have to take out truffle and build using web3js.

Happy Minting!!

Read more at http://www.dudistan.com/

Before I decided to write this piece, I did let my 11 years old go through a demo session of one such program which is now popular with almost every Bollywood celebrity endorsing it.

Before I go any further, let me establish my credentials. I have been in the business of programming for money for over 25+ years. In these years, I have seen multiple generations of programming languages. After all these years, I still code but that may be just 30% to 40% of my overall responsibilities as a Technical Director at a software development firm.

I strongly feel that it is meaningless to teach coding skills to children. Learning a programming language doesn’t mean anything to anyone. How to use & where to use programming skills, makes the most important part of programming. You can try to teach them how to write a pseudo code but not coding. Let them understand how to solve problems but they don’t need to know (yet) on converting a solution to a program (code).

There is a misconception that programmers merely know a programming language and just go about converting a defined solution to code. I don’t deny that such programmers or programming practices do exist but that breed is getting extinct pretty fast. Current day programmers (though I prefer to call them engineers) are expected to understand the business domain, medium of delivery (mobile, web or voice), localization (language & time zones), and many other such factors before starting to code.

Good or bad, our country had been churning out IT engineers at higher quantities than the market can absorb. Every year, a very small percentage of engineers find positions in various IT companies across the country. The rest of them try and enroll themselves with a ‘programming’ course and then try to find a position in the industry. In the end, a large percentage of these engineers, end up trying for a few more years before taking up other jobs.

Kids should go out and play. Let us try and help them to discover ‘learning’. Teach them how to approach learning guitar, playing cricket, or even telling stories on their own. When they understand ‘how to learn’ then they can learn a programming language or any skill for that matter when they grow up. Let us make them understand the ‘discipline’ of learning.

When I was a kid, I used to hear stories about emergence of Japan as super power after it has taken a severe beating in world war II. Imagine a country that was hit with 2 nuclear bombs fighting against all odds and coming out as one of best countries known for their engineering. I haven't heard about Japanese banning American goods as a revenge for bombing Hiroshima & Nagasaki. Never read anything like Japanese politicians calling for a ban on American imports to fight American superiority.

Let me make this very clear, I am not against calling for stopping Chinese imports.

Let me make this very clear, I am not against calling for stopping Chinese imports. I decided write this article after I came across a video of a man who happens to be an inspiration for the lead character in the movie '3 Idiots', Sonam Wangchuk, asking Indians to stop using Chinese made products. Well, he is not the first one, I have seen a number of whatsapp forwards preaching it to be a National duty to not to buy Chinese goods. There is nothing wrong with these messages. But before doing so, like stop buying Chinese products, let us analyze a bit more.

The sales of all brands of Mobile phones should seize immediately except for a few lesser known Indian brands.

There could be 2 important reasons for a seller to sell Chinese imported goods. one, a similar product is not available in India, two, even if it is available, it is priced much higher than Chinese import. Many of us don't realize the extent to which Chinese imports invaded our lifestyles. If people have to take these messages seriously, then they shouldn't be buying any brand of TV except Micromax or few such Indian made ones. The sales of all brands of Mobile phones should seize immediately except for a few lesser known Indian brands. Why would someone pay their hard earned money to buy a brand that is not very well know for their quality instead of a well known Chinese brand. On the second point of competing products already existing in India, there is something wrong with those Indian sellers who cannot do their pricing right even after Chinese imports have to pay their import duty. Govt should consider levying higher import duty to compensate higher labor costs in India compared to China.

Let us create an environment where the youngsters are encouraged to become entrepreneurs and not mere salaried employees.

No, I am not suggesting that we live with this situation. Let us try match every Chinese product with our own make. Let us create an environment where the youngsters are encouraged to become entrepreneurs and not mere salaried employees. Let us set high standards in engineering quality and get the rest of world import from us. Using Chinese products has nothing to do with patriotism. Remember, had we not opened up India for foreign products, we would have been driving only Ambassador cars, HERO would be confined to just making Cycles and short commute would been on Suvega mopeds. Let us invite competition but do a kickass engineering.

I have interests in Alexa, Angular / AngularJS, NodeJS, Ethereum Blockchain, ChatBOTS and many more. Read more at http://www.dudistan.com/

is what I heard during a conversation today. Do you think so? To substantiate, I was told that Mid to Smaller size IT Services / Consultancy or Startup accelerators should not aim at superior engineering instead do just what is needed to sail over.

Mid to Smaller size IT Services / Consultancy or Startup accelerators should not aim at superior engineering instead do just what is needed to sail over.

Well!! I beg to differ. I understand that you can’t set goals in engineering quality excellence and achieve it. This is because of constant change in the technology and other related areas which makes excellence a moving goal post. But that doesn’t mean that you shy away from it. It is imperative to devise a plan and find a way to achieve it. Like they say, more than achieving the goal of excellence, the journey is more important. The very fact that someone is thinking about will set the rest of stakeholders thinking about excellence. Also, it doesn’t just mean that you are writing the best code ever written and claim to be excellent, but the whole process.

Like they say, more than achieving the goal of excellence, the journey is more important.

IT Services industry has gone through some dramatic changes with the advent of Cloud, DevOps and other automation-related technologies. These new-age technologies have led to the birth of numerous Mid to Small IT Services / Consulting companies. Clients now are at liberty to choose a player with specific skills & expertise to address a specific business case unlike before where one IT giant will deliver all the services. This has rationalized the whole IT services market which has led to so many IT professionals who came to industry around the mid 90s becoming entrepreneurs. It all starts with the entrepreneur’s own area expertise. It could be a specific programming language like C++, Java or tools like SAP, Salesforce or domain like Finance, Retail. They will start small with 5 to 10 FTE (Full Time Employees) and then quickly grow to 100 to 200.

Clients now are at liberty to choose a player with specific skills & expertise to address a specific business case unlike before where one IT gaint will deliver all the services.

Eventually, some of these companies can reach nearly 1000 FTEs based on their ability to attract multiple clients. Just when the entrepreneur thinks he can breathe easy, it all starts. They will have to start expanding to other areas, beyond what is perceived to be the area of expertise, to sustain. Also, they need to constantly refine & rejuvenate their processes around project management as well as delivery to stay relevant. Even if there is a turnover of talent which is very obvious, the quality of engineering will have to be maintained. It is easier said than done.

Please don't reduce it to just a group that defines coding standards and uploads it to internal code storage or team portal.

To start with it needs to be recognized as important enough. Again, need to understand that it is an ongoing exercise and not one-off. There should be a CoE (Center of Excellence) for each technology area or domain. Please don’t reduce it to just a group that defines coding standards and uploads it to internal code storage or team portal. Set up a review of all the engineering work delivered and make sure to compare it with the benchmark. It is about questioning every line of code and checking if there is a better way to do it. All these need to happen in a friendly environment and not the way. Encourage people to start contributing to OpenSource projects, one of the ways to stay relevant to coding practices. Reward & recognize those who take an active role in these activities. For all these, you need to have a mindset. It doesn’t happen all by itself you will have to make an effort.

I have interests in Alexa, Angular / AngularJS, NodeJS, Ethereum Blockchain, ChatBOTS and many more. Read more at http://www.dudistan.com/

using Google App Engine, Google Cloud SQL, Google Data Studio and Python (wait for the embedded graph to load below)

I was trying to practice my python programming skills and decided to write python cron jobs. I realized that if I have to run cron jobs then I need server to host these cron jobs and configure them to run. Then I looked up Google cloud for a cloud service to run cron jobs. I realized that I can use Google App Engine to create and host my cron jobs.

To start with, I downloaded the Google Cloud SDK in order for me to write the program on my desktop, test it and then deploy on the Google Cloud when it is ready. You should download the Google Cloud SDK and configure it.

My project folder consists of 3 main files. app.yaml that holds the app configuration. cron.yaml that holds the cron frequency & other related info and main.py that has the main program. This may not be most efficient way of doing what I tried to do. Now that I know how to do it, I would love to make it more efficient and more compact.

app.yaml

runtime: python27
api_version: 1
threadsafe: yes
service: vue-scrape

libraries:
- name: lxml
  version: 3.7.3
- name: MySQLdb
  version: 1.2.5

handlers:
- url: .*
  script: main.app

env_variables:
    CLOUDSQL_CONNECTION_NAME: xxxxxxxxxxxxxxxxxxxxxx
    CLOUDSQL_DSN: mysql:unix_socket=xxxxxxxxxxxxxxxxxx
    CLOUDSQL_USER: root
    CLOUDSQL_PASSWORD: xxxxxxxxx

cron.yaml

cron:
- description: "angular scrape job"
  url: /angular
  target: angular-scrape
  schedule: every 24 hours
- description: "react scrape job"
  url: /react
  target: react-scrape
  schedule: every 24 hours  
- description: "vue scrape job"
  url: /vue
  target: vue-scrape
  schedule: every 24 hours    

main.py

import logging
import urllib
import urllib2
from google.appengine.api import urlfetch
import webapp2
from lxml import etree
from StringIO import StringIO
import os
import MySQLdb
from datetime import datetime

CLOUDSQL_CONNECTION_NAME = os.environ.get('CLOUDSQL_CONNECTION_NAME')
CLOUDSQL_USER = os.environ.get('CLOUDSQL_USER')
CLOUDSQL_PASSWORD = os.environ.get('CLOUDSQL_PASSWORD')

def connect_to_cloudsql():

    if os.getenv('SERVER_SOFTWARE', '').startswith('Google App Engine/'):
        cloudsql_unix_socket = os.path.join(
            '/cloudsql', CLOUDSQL_CONNECTION_NAME)

        db = MySQLdb.connect(
            unix_socket=cloudsql_unix_socket,
            user=CLOUDSQL_USER,
            passwd=CLOUDSQL_PASSWORD)

    else:
        db = MySQLdb.connect(
            host='127.0.0.1', user=CLOUDSQL_USER, passwd=CLOUDSQL_PASSWORD)

    return db

class UrlPostHandler(webapp2.RequestHandler):
    def get(self):
        try:
            headers = {'Content-Type': 'application/x-www-form-urlencoded'}
            result = urlfetch.fetch(
                url='https://www.xxxxxx.com/vue-jobs-in-hyderabad', #replace with job site of your choice
                method=urlfetch.POST,
                headers=headers)
            parser = etree.HTMLParser() 
            tree   = etree.parse(StringIO(result.content), parser)      
            if result.status_code == 200:
                self.response.write(result.content)
                logging.info(tree.find('.//title').text.split("-")[1].split(" ")[1].strip())
                db = connect_to_cloudsql()
                cursor = db.cursor()
                cursor.execute("INSERT INTO `cityjobs`.`jobtrack`(`tech`, `city`, `logdate`, `count`) VALUES ('" + "vue" +"', '" + "hyderabad" +"', '" + datetime.today().strftime('%Y-%m-%d') + "', '" + tree.find('.//title').text.split("-")[1].split(" ")[1].strip() + "');")
                db.commit()
                cursor.close()
                db.close()
            else:
                self.response.status_code = result.status_code
        except urlfetch.Error:
            logging.exception('Caught exception fetching url')

app = webapp2.WSGIApplication([
    ('/vue', UrlPostHandler),
], debug=True)

Once you have the code setup on the your desktop, you can start testing it using Google Local Development Server. Using this you can check if your code is going to work fine once it is deployed.

In my case, I created three different services for each of the frameworks ( as I said may not be efficient way of doing it) and then I created one cron.yaml that schedules all the services. For the purpose of the this code to run, I had created a Cloud SQL project with MySQL as the DB of choice and created a table based on the info that I wanted to record. Once the code is ready and tested locally, I first deployed each service by gcloud app deploy. As you can see, I had to make changes in the main.py as well as app.yaml before I deployed the service for each framework. Then I used same gcloud app deploy cron to deploy cron.yaml. As you keep deploying, you can verify the deployed service / cron on your Google Cloud console.

Once I have the data pumping into my Cloud SQL db, I created a data visualization using the Google Data Studio. You can connect to you db and plug-in the table that has the values. With a bit of trial & error, I got the graph view that I wanted.

I had fun building it. Happy coding.

I have interests in Alexa, Angular / AngularJS, NodeJS, Ethereum Blockchain, ChatBOTS and many more. Read more at http://www.dudistan.com/

OmniChannel is not a buzzword any more. If you haven't heard about it yet, then it is a cross channel strategy to engage with customers. Which effectively means that you have a way to deal with customers who use different channels - Web, telephone, Voice BOT or CHAT BOT to reach out to you for support. While it is fairly easy to build or implement a strategy across channels with the so many tools & technologies available, it becomes difficult to when users switch channels. User will switch channels when he or she feels that no one is addressing their concern. Someone needs to keep tab on these escalations as they pass through the channels. We need to identify and address such incidents before they are blown out of proportions. Imagine a customer who is very disappointed as he or she didn't get a response from any channels as a supervisor it shows up on your dashboard before blows out.

I decided a build a small Proof-Of-Concept involving some key channels. In place of Web interface, I built a small web page to capture customer query. For the sake of POC, I picked firebase as the DB to store all the analytics and JIRA for ticket creation & tracking.

Email

• Set up a small RPA bot that reads a mail as it arrives
• The text on the mail is analyzed using Google text analytics for sentiment
• The text as well as sentiment score is sent to a central DB and stored against the customer id & Ticket id?

Messenger Chat

• We can log all chat responses and conduct text analytics in real time using Google text analytics for sentiment
• The text as well as sentiment score is sent to a central DB and stored against the customer id & Ticket id?

Voice BOT

• We can use Alexa or Dialogflow (telephone integration module) to log all the spoken text/words over a conversation and do a real time analytics using Google API
• The text as well as sentiment score is sent to a central DB and stored against the customer id & Ticket id?

Web Interface

• We can set up a web page that pulls all the text & sentiment score against specific customer or ticket (as stored) and aggregates on the page
• The basic aggregate score can be overall sentiment across all channels/text.

In the below code snippet, callmapi() function reads the email from the designated mailbox and then calls crtjiratkt function that creates a JIRA ticket and then getsent function is called which sends the text to Google Speech analytics to get the sentiment score.

const notifier = require('mail-notifier');
var Imap = require('imap'),
    inspect = require('util').inspect;
var fs = require('fs'), fileStream;
var cmd = require('node-cmd');
const request = require('request');
const firebase = require('firebase');
const admin = require('firebase-admin');


var imap1 = {
    user: "your-mailbox@gmail.com",
    password: "mailpassword",
    host: "imap.gmail.com",
    port: 993, // imap port
    tls: true,// use secure connection
    tlsOptions: { rejectUnauthorized: false }
};

var config = {
    apiKey: "your-key-goes-here",
    authDomain: "yourdb.firebaseapp.com",
    databaseURL: "https://yourdb.firebaseio.com",
    projectId: "your-projectid",
    storageBucket: "yourdb.appspot.com",
    messagingSenderId: "000000000"
  };
firebase.initializeApp(config);

admin.initializeApp({
    credential: admin.credential.cert({
      projectId: 'your-projectid',
      clientEmail: 'firebase-adminsdk-0000@your-projectid.iam.gserviceaccount.com',
      privateKey: '-----BEGIN PRIVATE KEY----------END PRIVATE KEY-----\n'
    }),
    databaseURL: 'https://your-projectid.firebaseio.com'
  });

function callmapi() {
    notifier(imap1)
    .on('mail', mail => {
        console.log('from : ' + mail.from[0].address);
        console.log('subject : ' + mail.subject);
        //console.log(mail);
        crtjiratkt(mail.text, function(key){
        getsent(mail.text, function(score){ 
            console.log(mail.text + " = " + score)
            admin.database().ref('scores/').push({
                channel: 'email',
                cname: mail.from[0].name,
                cscore: score,
                ctext: mail.text,
                cmail: mail.from[0].address,
                tdesc: mail.subject,
                ticket: key
              }, function(error) {
                  console.log(error);
              });
        })
      })
    })
    .on('error', err => {
        console.log(err);
    })
    .on('end', () => n.start())
    .start();

function getsent (tline, callback) {
    let options1 = { method: 'POST',
    url: 'https://language.googleapis.com/v1beta2/documents:analyzeSentiment?key=your-key-goes-here',
    headers:
        {   'cache-control': 'no-cache',
            'content-type': 'application/json' },
    body:
        {
          'document':{
          'type':'PLAIN_TEXT',
          'content': tline
        }
      },
    json: true };

    request(options1, function (error, response, body) {
    //console.log(response);
    if (body.error != 'undefined') {
      callback(body.documentSentiment.score);
    } else {
      callback(0);
    }


  });
}

function crtjiratkt(tline, callback) {
  var options = { method: 'POST',
  url: 'https://test.atlassian.net/rest/api/2/issue/',
  headers: 
   { 'Postman-Token': 'a4536d1b-ff9c-4de7-a9c7-6a30417f61a2',
     'Cache-Control': 'no-cache',
     Authorization: 'Basic xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
     'Content-Type': 'application/json' },
  body: 
   { fields: 
      { project: { key: 'RPA' },
        summary: tline,
        description: 'Instance Name : DevInstanceforTesting\nImages              : Cirros\nFlavor               : m1.small\nRequester         : test@test.com',
        issuetype: { name: 'Task', Assignee: 'BOT' } } },
  json: true };

  request(options, function (error, response, body) {
    if (error) throw new Error(error);
    if (body.error != 'undefined') {
      callback(body.key);
      console.log(body);
    } else {
      callback(0);
    }
  });  
}

In the below code snippet which is inserted in the dialogflow 'Webhook', intercepts the chat responses in exports.chatbot which in turn polled to Google Speech analytics for a sentiment score (getsent).

const request = require('request');
const admin = require('firebase-admin');

admin.initializeApp({
    credential: admin.credential.cert({
      projectId: 'your-projectid',
      clientEmail: 'firebase-adminsdk-0000@your-projectid.iam.gserviceaccount.com',
      privateKey: '-----BEGIN PRIVATE KEY----------END PRIVATE KEY-----\n'
    }),
    databaseURL: 'https://your-projectid.firebaseio.com'
  });


exports.chatbot = (req, res) => {
  /*let message = req.query.message || req.body.message || 'Hello World!';
  res.status(200).send(message);*/
  //console.log(req.body.queryResult.intent);
  if (req.body.queryResult.intent.displayName == "Default Welcome Intent - custom - yes - custom - custom") {
     getsent(req.body.queryResult.queryText, function(score){
             admin.database().ref('scores/').push({
                channel: 'chat',
                cname: 'prakash',
                cscore: score,
                ctext: req.body.queryResult.queryText,
                cmail: 'test mail',
                tdesc: 'test subject',
                ticket: 'abc234'
              }, function(error) {
                  console.log(error);
              });
         console.log(req.body.queryResult.queryText + ":" + score);
     })
  }
  else if (req.body.queryResult.intent.displayName == "Default Welcome Intent - custom - yes - custom") {
    console.log("ticket no: " + req.body.queryResult.queryText);
  }
};

function getsent (tline, callback) {
    let options1 = { method: 'POST',
    url: 'https://language.googleapis.com/v1beta2/documents:analyzeSentiment?key=AIzaSyCh-H9fxZXaR43dQQgg4FIwLWpAX2L5C7E',
    headers:
        {   'cache-control': 'no-cache',
            'content-type': 'application/json' },
    body:
        {
          'document':{
          'type':'PLAIN_TEXT',
          'content': tline
        }
      },
    json: true };

    request(options1, function (error, response, body) {
    //console.log(response);
    if (body.error != 'undefined') {
      callback(body.documentSentiment.score);
    } else {
      callback(0);
    }


  });
}

https://cloud.google.com/natural-language/

I have interests in Alexa, Angular / AngularJS, NodeJS, Ethereum Blockchain, ChatBOTS and many more. Read more at http://www.dudistan.com/

Disclaimer : If you haven't watched the tamil movie 96 then this article will not make sense to you. If you haven't watched the movie yet then you probably should, especially if you are in mid 40s and preparing for life after 50.

The whole world is singing praises of Director Prem kumar and the lead protagonists Vijay Sethupathi and Trisha for the brilliant movie. Sometimes, it is that uncanny combination of right people, right story and some brilliant acting that creates the magic. Well!! I am not going to be one of those movie reviewers to analyze the movie for its story, acting, DOP and of course brilliant music by Govind Vasanthan. I would rather focus on the what this movie did to people who watched it.

Let us first deal with the nahsayers. The big question is about kids/teens falling in love at a young age. Is it believable? Is it really possible? But a large section of us out there who experienced it can vouch that it is possible. Initially it may be a simple appreciation & liking before it becomes heart thumping (literally, in the movie). This is of course when the other person takes equal interest in you and probably starts responding in some way, like as simple as a smile. Is your heart thumping?

What if, Ram was married? Would Jaanu cry her heart out while leaving the airport? or they would have dealt with the situation with same maturity

A friend of mine did get in touch with a girl that he 'thought' was interested in him some 25 years back. In the aftermath of the movie, he got inspired to go look for this girl with whom he hardly spoke even during those years when he knew her. With a bit of research on facebook and some help from her friends, he eventually got hold of her phone number. He couldn't bring himself to call the girl instead he sent a whatsapp message and waited with bated breath for her response. Eventually she responded. After exchanging couple of messages, he realized that she was't really excited to meet him. He quickly realized that everything that he thought was just figment of his imagination. It was a huge disappointment. He realized that he was of better off living with that beautiful memory. It was hard but he is making an effort to move on.

Not very often you common across something that will leave a long lasting impression. It could be a person, an event or a place. You are a different person after that. It will take sometime to sink in.

I recently witnessed, better still, been part of an event that changed me completely. For everyone else it was just a school reunion but for us it was a REUNION. Imagine this, close to 100 individuals (out of overall nearly 200) belonging to same batch meeting after 30 long years. You have to be one of those 100 to understand what it really means. These are people you grew up with. You fought, you cried, you laughed and went through hell a lot of emotions during your childhood. The same set of individuals sitting together and sharing a laugh but this time, little more mature, little more caring and little more love. It is like a treasure trove of friends that you discovered accidentally. Your life suddenly becomes little more interesting and a bit more worthwhile. I see this being a perfect remedy for anyone having a midlife crisis if there is one.

So, who should get credited for this REUNION? The organizers who worked tirelessly or the participants who set aside everything to be there at the event. I think it is both and something more. It is the alma mater, in this case the school itself and of course the amazing teachers. Somewhere it is something to do with the value system that teachers passed on. It may not be just the enthusiasm to meet each other that brought so many of them to the event, it is about commitment to friendship. People stood up to so many people working hard for the event. I feel that it may not be as successful had this event was done 10 or 20 years back. It has also something to do with almost all the individuals being between 45 to 46 years old. There was this feeling that if not now, it will never happen.

Have a great life!!