• Purpose: Find information across platforms (Jira, Confluence, SharePoint, Google Drive, etc.).

• Key Benefits:

  • Improves accuracy by tailoring queries.

  • Respects user permissions (only shows what you can access).

  • Supports filtering by app and contributor.

• Features:

  • Knowledge Cards: Provide instant insights (definitions, summaries).

  • Multi-colored underline (Confluence): Rovo already has a definition.

• Integrations:

  • SharePoint → Searchable directly in Rovo.

  • Google Sheets → Requires admin-added Google Drive connector.

• Correction Method:

  • Use “bad response” feedback to report incorrect definitions.

Rovo Chat

• Primary Use: Summarize content from multiple sources.

• Getting Started: Open Rovo Chat and type a query.

• Chat History: Users can review their own past chats.

• Access Anywhere: Available via the Rovo Chrome Extension.

Rovo Agents

• What They Do:

  • Automate workflows and repetitive tasks.

  • Triage requests.

  • Generate project updates from Jira.

• Creation (No Code):

  • Built using Rovo Studio.

• Automation:

  • Can be added to automation rules.

  • Support scheduled tasks (e.g., weekly summaries to Slack).

Rovo Studio

• Purpose: No-code / low-code tool to create Rovo Agents.

• Audience: Non-developers and business users.

Rovo Chrome Extension

• Main Advantage:

  • Access Rovo Search and Chat from any browser tab or public web page.

• Does NOT:

  • Grant access to Google Drive or other tools by itself.

Teamwork Graph

• Use Case:

  • Gain insights about team members, relationships, and work context.

• Not For: Definitions or term explanations.

TCREI Framework

• Evaluate & Iterate:

  • Review responses, identify gaps, and refine prompts.

Key Exam Reminders

• Rovo never bypasses permissions.

• Admins control connectors (Google Drive, SharePoint).

• Users cannot edit definitions directly.

• Automation + Agents = true hands-off workflows.

This guide will walk you through setting up Jest for Node.js, testing SQL interactions, and validating XML structure. By the end, you’ll understand how to mock SQL queries, validate XML, and run tests in Jest with ease.

Prerequisites

To follow along, you should have:

1. A Node.js application setup.

2. Basic understanding of SQL and XML.

3. Jest installed as a development dependency.

Install Jest and Dependencies

Let’s get started by installing Jest, an SQL client (e.g., mssql for SQL Server), and an XML parser (fast-xml-parser).

# Initialize the project and install Jest
npm init -y
npm install --save-dev jest

# Install an SQL client (e.g., `mssql` for SQL Server)
npm install mssql

# Install an XML parser to validate XML structure
npm install fast-xml-parser

Setting Up Jest

Once installed, configure Jest by adding a "test" script in your package.json:

jsonCopy code"scripts": {
  "test": "jest"
}

This setup will enable you to run Jest using npm test from the command line.

Mocking SQL Functions

Let’s create a simple example to test SQL queries without needing an actual database connection. We’ll use mocking to simulate SQL database interactions, allowing us to isolate and test only the code logic.

Step 1: Create a Database Connection Module

First, create a db.js file with a function to connect to your SQL database. This keeps your SQL configuration separate, making it easier to test.

// db.js
const sql = require('mssql');

const config = {
  user: 'yourUsername',
  password: 'yourPassword',
  server: 'yourServer',
  database: 'yourDatabase',
  options: {
    encrypt: true,
    enableArithAbort: true,
  },
};

const connectToDB = async () => {
  try {
    const pool = await sql.connect(config);
    return pool;
  } catch (err) {
    console.error('Database connection failed:', err);
    throw err;
  }
};

module.exports = { connectToDB };

Step 2: Write a Function to Fetch Data

Let’s say we want a function to retrieve a user by ID. This function will run a SQL query to get user information.

// userService.js
const { connectToDB } = require('./db');

const getUserById = async (userId) => {
  const pool = await connectToDB();
  const result = await pool
    .request()
    .input('userId', sql.Int, userId)
    .query('SELECT * FROM Users WHERE id = @userId');
  return result.recordset[0];
};

module.exports = { getUserById };

Step 3: Mock the SQL Database in Jest

To test this function, we’ll use Jest’s jest.mock() method to replace the real database connection with a mock. This lets us test our function without needing an actual database.

// userService.test.js
const sql = require('mssql');
const { getUserById } = require('./userService');

jest.mock('mssql'); // Mock the mssql module

describe('User Service', () => {
  it('should return user data for a valid userId', async () => {
    // Mock response data
    const mockData = { id: 1, name: 'John Doe' };
    const request = { input: jest.fn().mockReturnThis(), query: jest.fn().mockResolvedValue({ recordset: [mockData] }) };
    const pool = { request: jest.fn().mockReturnValue(request) };

    sql.connect.mockResolvedValue(pool); // Mock the connection to return our mock pool

    const result = await getUserById(1);

    // Validate the result
    expect(result).toEqual(mockData);
    expect(pool.request).toHaveBeenCalled();
    expect(request.input).toHaveBeenCalledWith('userId', sql.Int, 1);
    expect(request.query).toHaveBeenCalledWith('SELECT * FROM Users WHERE id = @userId');
  });
});

In this test:

• We mock the SQL connect() function to return a fake pool object.

• We mock the query function to return a predefined user (mockData), simulating a successful database query.

• Jest verifies that the function behaves as expected without hitting a real database.

Testing XML Validation

Next, let’s test XML files to ensure they include required fields. For example, each <user> in the XML might need an <id>, <name>, and <email> field.

Step 1: Write an XML Validator Function

In xmlValidator.js:

const { XMLParser } = require('fast-xml-parser');

const validateMandatoryFields = (xmlData, requiredFields) => {
  const parser = new XMLParser();
  const jsonObj = parser.parse(xmlData);

  // Check each required field
  const missingFields = requiredFields.filter((field) => {
    const parts = field.split('.');
    let obj = jsonObj;
    for (const part of parts) {
      if (!obj || !obj[part]) {
        return true;
      }
      obj = obj[part];
    }
    return false;
  });

  return missingFields.length === 0;
};

module.exports = { validateMandatoryFields };

This validateMandatoryFields function:

1. Converts the XML into JSON.

2. Checks if each required field (e.g., user.id, user.name, user.email) is present.

3. Returns true if all fields exist, otherwise false.

Step 2: Write Jest Tests for XML Validation

Now, let’s create tests to check that validateMandatoryFields works as expected.

In xmlValidator.test.js:

const { validateMandatoryFields } = require('./xmlValidator');

describe('XML Validator', () => {
  it('should return true if all mandatory fields are present', () => {
    const xmlData = `
      <user>
        <id>1</id>
        <name>John Doe</name>
        <email>johndoe@example.com</email>
      </user>
    `;
    const requiredFields = ['user.id', 'user.name', 'user.email'];
    const isValid = validateMandatoryFields(xmlData, requiredFields);

    expect(isValid).toBe(true);
  });

  it('should return false if mandatory fields are missing', () => {
    const xmlData = `
      <user>
        <id>1</id>
        <name>John Doe</name>
      </user>
    `;
    const requiredFields = ['user.id', 'user.name', 'user.email'];
    const isValid = validateMandatoryFields(xmlData, requiredFields);

    expect(isValid).toBe(false);
  });
});

This test suite checks two scenarios:

• Success case: All required fields are present, so isValid should return true.

• Failure case: Missing fields cause isValid to return false.

Now, all you have to do is chant the magic incantation:

npm test

Running Jest Tests for Specific Files

To run tests for a particular file, specify the path in the jest command:

npm jest path/to/file.test.js

For example, to run only userService.test.js:

npm jest userService.test.js

You can also use patterns to match filenames:

npm jest user

This command will run all tests with “user” in the filename, making it easy to focus on specific areas during development.

Conclusion

Using Jest to test SQL functions and XML validation in Node.js can improve reliability and make development faster. With Jest’s mocking capabilities, you can avoid real database interactions in tests, and XML validation ensures structured data is complete.

Key Takeaways

• Mock SQL Connections: Avoid hitting the database during tests by mocking SQL connections.

• XML Validation: Ensure XML files have all mandatory fields.

• Run Specific Tests: Run tests for individual files or patterns to quickly validate specific functionality.

With Jest, you’re equipped to write robust, reliable tests that make your Node.js application easier to maintain and extend.

Essential Building Blocks:

• Elastic Compute Cloud (EC2): As mentioned before, EC2 forms the bedrock of AWS, providing on-demand virtual servers. Think of it as a vast pool of computing power, ready to scale up or down at your whim. Need to analyze terabytes of data? Spin up a cluster of EC2 instances. Building a robust backend for your mobile app? EC2 scales with your user base effortlessly.

• Simple Storage Service (S3): Data, glorious data! S3 remains your one-stop shop for storing all types of data objects – from application logs to media libraries. S3 boasts scalability, exceptional durability, and affordability, making it the go-to service for cloud storage.

• Relational Database Service (RDS): Databases are the lifeblood of many applications. RDS streamlines database management by offering managed relational database services for popular engines like MySQL, PostgreSQL, and Aurora. Say goodbye to the hassles of setting up, patching, or scaling your database – RDS handles it all.

Beyond the Basics:

• Amazon DynamoDB: For workloads demanding NoSQL databases with low latency and high performance, DynamoDB is your champion. Built for scalability and fault tolerance, DynamoDB is ideal for mobile backends, gaming applications, and internet-of-things (IoT) use cases.

• Amazon Elastic Kubernetes Service (EKS): Containerization is all the rage, and EKS provides a managed Kubernetes service for deploying and scaling containerized applications. Focus on building your apps; EKS takes care of managing the Kubernetes cluster, simplifying deployments and operations.

• Amazon Simple Notification Service (SNS): Need a highly scalable and cost-effective way to send notifications across different distributed applications? SNS is your answer. It allows you to publish messages to various topics, and subscribers can receive those messages according to their interests.

Security and Management:

• Amazon Cognito: User authentication is crucial, and Cognito provides user identity services for your web and mobile apps. Cognito simplifies user registration, login, and access control, allowing you to integrate social sign-in and implement multi-factor authentication (MFA) for enhanced security.

• Amazon CloudWatch: Keeping tabs on your AWS resources is essential. CloudWatch provides comprehensive monitoring and observability tools, allowing you to track resource utilization, application performance, and set custom alarms for proactive issue detection.

• AWS CloudTrail: Security is paramount. CloudTrail acts as your AWS auditor, recording API calls made to your AWS account. With CloudTrail, you can monitor user activity, track changes made to your resources, and fulfill regulatory compliance requirements.

Machine Learning and Artificial Intelligence (AI):

• Amazon SageMaker: Machine learning (ML) can be daunting, but SageMaker streamlines the entire ML lifecycle. From data preparation to model training and deployment, SageMaker offers a managed service that empowers you to build, train, and deploy ML models seamlessly.

• Amazon Rekognition: Want to leverage image and video analysis in your applications? Rekognition is an image and video recognition service that allows you to identify objects, scenes, and even people in your visual content. Perfect for building applications like content moderation, security surveillance, and automated image tagging.

Content Delivery and Networking:

• Amazon CloudFront: Delivering content to users across the globe with low latency requires a robust content delivery network (CDN). CloudFront excels in this domain, caching your content in geographically distributed edge locations, ensuring fast and reliable delivery of your static and dynamic content to your users.

• Amazon Virtual Private Cloud (VPC): Security is a top priority. VPC lets you create a logically isolated virtual network within the AWS cloud. You can define your own IP address range, configure security groups to control network traffic, and create subnets for specific use cases within your VPC.

This list barely scratches the surface of the vast array of services offered by AWS. From services for analytics (Amazon Redshift) to business intelligence (Amazon QuickSight), and from blockchain (Amazon Managed Blockchain) to the Internet of Things (AWS IoT Core), AWS has a service for nearly every conceivable need.

Ready to Unleash the Power of AWS?

With its extensive suite of services, unwavering focus on scalability and security, and its pay-as-you-go pricing model, AWS empowers businesses of all sizes to innovate and thrive in the cloud. Whether you're a budding startup or a seasoned enterprise, AWS has the tools and resources to propel your applications and business to new heights.

So, dive into the world of AWS and explore the possibilities! The AWS website offers a plethora of resources, including tutorials, documentation, and case studies to get you started. With a little exploration, you'll discover how AWS can be the engine that drives your success in the cloud.

What is AutoSys?

Think of AutoSys as your trusty IT conductor, meticulously scheduling and running tasks across your entire infrastructure. From routine backups to intricate data processing pipelines, AutoSys automates these critical processes, ensuring timely execution and error-free operation. Whether you're managing servers, applications, or data, AutoSys streamlines your workflows, boosts efficiency, and frees up your team for more strategic endeavors.

Creating Jobs in AutoSys:

Crafting jobs in AutoSys is surprisingly intuitive, thanks to the Job Information Language (JIL). Imagine JIL as your recipe book for automation, where you define the ingredients (scripts, commands, parameters) and instructions (scheduling, dependencies) for your desired outcome.

Here's the basic JIL recipe for creating a new job:

1. Start with the basics: Define the job name, type (command, script, box), and owner. "Backup_script" as your job name, c for a command type, and your username as the owner could be your starting point.

2. Specify the action: Tell AutoSys what to do! Use the "command" attribute to reference the script or executable to be run. Remember, backup.sh could be your command in this case.

3. Choose your platform: Determine where the job should run by specifying the machine name, like "backup_server."

4. Schedule your workflow: Define the job's execution frequency. For daily backups, use "days_of_week: all" and "start_times: 02:00."

5. Refine the details: Set additional attributes like error handling with "alarm_if_fail: 1" and output capture with "std_out_file: /logs/backup.log."

That's it! Save your JIL script and run it with the jil command to see your automated job spring to life.

Updating and Deleting Jobs:

Your needs evolve, and so should your automation. AutoSys makes it easy to update and delete existing jobs. For updates, simply modify the relevant attributes in your JIL script and re-run it. To delete a job, use the delete_job: <job_name> command in JIL. Remember, with great power comes great responsibility, so use the delete command cautiously!

Beyond the Basics:

This is just a taste of AutoSys's vast capabilities. From dependencies and conditions to file watchers and global variables, there's a treasure trove of features to explore. Don't hesitate to dive deeper into the JIL documentation and discover how AutoSys can truly transform your IT operations.

Sample Scripts:

Want to see these concepts in action? Here are some sample JIL scripts:

• Creating a simple command job:

/* ----------------- Job Name ----------------- */
insert_job: <job_name>
job_type: <job_type>
command: <command_to_execute>
machine: <machine_name>
owner: <job_owner>
permission: <permissions>
description: <job_description>
std_out_file: <standard_output_file>
std_err_file: <standard_error_file>
alarm_if_fail: <0_or_1>
/* ----------------- Additional Attributes ----------------- */
/* Add other attributes as needed, such as:
   box_name, max_run_alarm, priority, days_of_week, start_times, condition...
   Refer to your CA Workload Automation AE documentation for more details. */

Example:
/* ----------------- Daily Backup Job ----------------- */
insert_job: daily_backup
job_type: c
command: /usr/bin/backup.sh
machine: backup_server
owner: admin
permission: gx,wx
description: "Runs the daily backup script"
std_out_file: /logs/backup_out.log
std_err_file: /logs/backup_err.log
alarm_if_fail: 1
/* ----------------- Scheduling ----------------- */
days_of_week: all
start_times: "02:00"
/* ----------------- Dependencies ----------------- */
condition: s(database_backup)
/* ----------------- Other Attributes ----------------- */
max_run_alarm: 120

• Updating an existing job:

update_job: sample_job
command: /bin/echo "The job has been updated!"

• Deleting a job:

delete_job: sample_job

• Creating a file watcher job:

insert_job: <job_name>
job_type: c
command: <command_to_execute_when_file_arrives>
machine: <machine_name>
watch_file: <file_path_and_name>
max_run_alarm: <maximum_runtime_before_alarm>
alarm_if_fail: <0_or_1>
/* Additional attributes as needed */

Example:
insert_job: process_datafile
job_type: c
command: /apps/process_data.sh
machine: data_server
watch_file: /data/incoming/datafile_*.csv
max_run_alarm: 60
alarm_if_fail: 1

• Executing a JIL script from a file:

jil < script.jil > script.out

Executing Multiple Scripts:

Want to run multiple JIL scripts from one file? No problem! Use the include statement:

include: "script1.jil"
include: "script2.jil"

Remember, order matters, and errors in included scripts can stop execution.

However, Node.js evolves at lightning speed. It feels like there’s a new upgrade almost every other month, and by the time I was ready to start a new project, I’d have to update to the latest Node.js version to access the newest features.

But here’s the catch: when I revisited my old projects, I’d be greeted by a barrage of red error messages. Suddenly, my previously smooth-running project was plagued with npm packaging incompatibilities and other issues. It was frustrating to say the least.

Enter Node Version Manager (NVM). This nifty tool allows you to manage multiple Node.js versions on your machine, making it easy to switch back and forth based on your project requirements. Let’s dive into how you can harness the power of NVM:

Installing NVM

Windows Users

If you’re on Windows, fear not! While NVM is primarily supported on Linux and Mac, there’s a similar tool called nvm-windows that provides an NVM-like experience for Windows users. Here’s what you need to do:

1. Visit the NVM for Windows GitHub repository.

2. Download the latest version of the installer from the releases page.

3. Run the installer and follow the on-screen instructions.

Linux and Mac Users

For Linux and Mac users, open your terminal and execute the following command to install NVM:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

or

wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

This command will clone the NVM repository to ~/.nvm on your device.

Using NVM

Now that NVM is installed, let’s explore its capabilities:

1. Installing Node.js Versions:

   • To install the latest version of Node.js, use:

       nvm install latest
     

   • To install a specific version (e.g., 14.17.0), run:

       nvm install 14.17.0
     

2. Setting a Default Version:

   • Set a default Node.js version with:

       nvm alias default 14.17.0
     

3. Switching Between Versions:

   • Use the following command to switch to a specific version:

       nvm use 14.17.0
     

Remember to uninstall any existing Node.js installations to avoid conflicts with NVM. Now you’re equipped to manage your Node.js versions effectively!

Happy coding! 🚀

Feel free to share this blog post with fellow developers who want to streamline their Node.js development workflow. If you have any questions or need further assistance, drop a comment below! 😊

Why is it called "Cloud Computing"?

The Cloud got its name when early Engineers needed a simple way to diagram complex networks connected through the internet. So they drew the bubbles around them, that looked like clouds and the name stuck.

Organizations of every type, size, and industry are using the cloud for a wide variety of use cases, such as data backup, disaster recovery, email, virtual desktops, software development, and testing, big data analytics, and customer-facing web applications. For example, health care companies are using the cloud to develop more personalized treatments for patients. Financial services companies are using the cloud to power real-time fraud detection and prevention. And video game makers are using the cloud to deliver online games to millions of players around the world.

With cloud computing, the business can become more agile, reduce costs, instantly scale, and deploy globally in minutes. Cloud computing gives you instant access to a broad range of technologies so you can innovate faster and build nearly anything you can imagine, from infrastructure services such as compute, storage and databases, to the Internet of Things, machine learning, data analytics, and much more.

You can deploy technology services in a matter of minutes and get from idea to implementation several orders of magnitude faster than before. This gives you the freedom to experiment and test new ideas to differentiate customer experiences and transform business, such as adding machine learning and intelligence to applications to personalize experiences for customers and improve their engagement. You don't need to make large, upfront investments in hardware and overpay for the capacity you don't use. Instead, you can trade capital expense for the variable expense and only pay for IT as you consume it.

Where is Cloud storage actually located?

Nothing is Up there! It turns out, internet infrastructure is actually very much earthbound. Every server and data center that makes up “The Cloud” is on land and chances are when you upload something to the cloud, you are not sending stuff up but you are sending stuff down through the ocean. Optical fiber - The Undersea Cloud.

With cloud computing, you access resources from the cloud in real-time as they're needed. You can scale these resources up and down to grow or shrink capacity instantly as business needs change. Cloud computing also makes it easy to expand to new regions and deploy globally in minutes. Cloud infrastructure is all over the world so you're able to deploy the application in multiple physical locations in just a few clicks. Putting applications in closer proximity to end users reduces latency and improves their experience. No matter location, size, or industry, the cloud frees you from managing infrastructure and data centers so you can focus on what matters most to business.

Linux is based on a philosophy that software and operating systems should be free. Both, free of cost and freely modifiable.

The software license which allows this, in the case of the Linux kernel, is called the GNU General Public License. This emphasis on freedom, both, cost and modification has helped Linux to become popular for many different applications and purposes. And Linux has popped up everywhere from the majority of the servers that run web services we all use to supercomputers, to your wifi router, in cars, mobile phones, and everywhere in between.

Amid all these different kinds of Linux installations, the most important distinction you'll need to be aware of is one of genealogy. While the Linux kernel is more or less the same across nearly all of these installations of Linux, the software that surrounds the kernel that provides capabilities like software package management, control of services, and the location of configuration files differs between them. Many of the tools that come packaged with Linux come from the GNU Project and aren't a part of Linux. And so, taken together, the combination of the kernel and these common tools is often referred to as GNU Linux. Different groups of software and configuration choices that are maintained by individuals or groups of people are called distributions, or distros.

Most major distributions of Linux fall into four categories based on the original distribution from which they were derived. There's Arch, Debian, Red Hat, and Slackware, and any number of other smaller distributions. Depending on your industry, your company, your institution, or any number of other factors, you're likely to end up learning to use the command line on a system that inherits from one of these distributions. Most likely, you'll be using one derived from Debian or Red Hat. Linux Mint, Ubuntu, Elementary OS, and Kali Linux are all derived from Debian. CentOS, Fedora, and Red Hat Enterprise Linux are derived from Red Hat. The history of all of these different distributions of Linux is kind of beyond the scope of this course. But, what this means at its core is that you'll need to be aware of what system you're using and that you may need to adapt what you're doing to account for differences in distributions.

As you begin working with Linux, through the command line, most of what you'll do is the same across the major distributions. That's because the text interface, the command line, is a program called a shell. The Bash shell, which is available almost everywhere. As you extend your learning and explore software packages and system administration you'll start to see differences.

Once you decide you want to build an iPhone app for instance then you would learn something called iOS, you need a Mac to do that and then you use a free tool called Xcode and you make apps using Objective-C. Instead of Objective-C, now people are started to use Swift. The way you sell those apps is in the App Store so you upload it to the App Store and then Apple okay’s it or doesn’t, hopefully, they’ll hit it, and then it goes in the store, and then you can charge real money for that and launch your app.

That way the next thing is if you decide to make an Android app. If you are going for an Android phone or an Android tablet, then you are building for Android. Android is the operating system of those devices and the tool that you use is usually like eclipse or Android studio. The actual language that you use to build those apps is called Java. And for the language of Android Apps development, Besides “Java”, a new language called Kotlin is started to gain popularity Maybe in a few month or years, people will abandon Java and goes for Kotlin, so better to do some more Google search before spend all your time into either Java or Kotlin for Android development. so that is the basic idea of mobile apps you code in these specific languages in these specific tools and then people download your apps from the Google Play Store and they pay for them.

That way now says instead you would rather build a website so you want to build a website for your restaurant or your dad’s business or your school. The tools that you use to build websites are basically a text editor and then you save your files and then you upload them to the Internet. The languages you need to learn are called HTML, CSS, and a little bit of JavaScript. Those are some of the easiest things to learn initially, you don’t have to do a lot of programming or a lot of technical things. They’re fairly straightforward so that’s how to build a website.

Now say that you want to build a website but you want people to interact with it. You want them to log in or you want them to know friend people or like things or create accounts. All those things turn that website into a web application. You know something that you interact with and examples that are you know things like Facebook, Google Maps is a good example. It’s very interactive. So if you want to build something like that first of all you pick a language to build it in.

Your choices are things like Node.js, Ruby, Python, Java there’s more but those are some of the most common ones. Once you pick a language then you would also pick a database. A database is a thing that holds all the information on the site. When you create an account and a password that is stored in the databases like Oracle, SQL, MongoDB. The tools used to make web apps are also text-based so you have text editors like VS Code, Atom, Sublime. and then you save your files and then you upload them to the internet. It’s similar to making a website but you use more powerful languages to make things happen. So we’ve covered so far mobile apps, websites, and web apps.

Now let’s address a little bit more about the types of jobs that you might get in those fields. All three of those things require three types of people. The first is a designer, the second is a front-end developer and the third is a back-end developer. A designer thinks about the way things look and how they work. They use tools like Photoshop, Illustrator various tools like that. They design it and they make it look great and then they hand it over to the next person which is a front-end developer. A front-end developer is some who takes that design. They chop it up and translate it into the code and they use tools like HTML CSS and JavaScript. Now, what’s happening more and more of those designers and front-end developers are becoming the same person. So at MNCs, they only hire designers that are also front-end developers so eventually it pays off to know both those skills. And then you have back-end developers, so a front-end developer will chop up the design and make it ready but it won’t work. You can look at it but you can’t log in or you can’t create an account that type of thing. So the back-end developer takes that and then they wire it up quote-unquote, they connected to the database, they write code to make the app work and function. They’re using tools like Node.js, Ruby, Python, Java things like that.

So that is the basic overview of how this fits together. It can be confusing at first but once you understand that there are these basic buckets, you know okay I want to make a mobile app or I want to make a website or I want to make a web app once you decide which of those three things you want to do then you can go down a track and learn it.

Happy Learning

At that time, I wasn’t very strong in current affairs — but I knew this one. With confidence, I replied, “Dr. APJ Abdul Kalam.”

He smiled, nodded, and then followed up with, “Good! Now tell me, what does APJ stand for?”

That question caught me off guard. I went blank. “I’m not sure,” I said, feeling a bit embarrassed.

That’s when he explained, “APJ means Avul Pakir Jainulabdeen.”

At first, I felt disappointed for not knowing something so basic. But soon, that feeling turned into pride — pride in learning the full name of one of the most respected leaders India has ever known.

A Man Beyond Titles and Power

India lost one of her greatest sons when Dr. Kalam left us. He was far more than just a scientist or the President — he was a visionary, a teacher, and above all, a humble human being.

He never led through authority; he led through inspiration and compassion. The admiration people have for him wasn’t inherited or demanded — it was earned through his honesty, hard work, and kindness.

Even today, as I scroll through social media, I see quotes, photos, and stories celebrating him. It’s a reminder that his influence still lives on — in classrooms, in dreams, and in the hearts of millions.

The Real “Superman” of India 🦸‍♂️

The media often called him the “Missile Man of India.” Indeed, he was the driving force behind India’s missile and defense technology, helping our nation secure its place among the global powers.

But to me, that title isn’t enough. He wasn’t just the Missile Man — he was India’s Superman.

He elevated the nation not only through science but through hope and belief. He showed us what true leadership looks like — not by commanding people, but by motivating them to rise higher.

Dr. Kalam’s work also transformed India’s space program. His dedication helped ISRO earn the recognition it enjoys today, standing proudly among agencies like NASA.

His Greatest Investment: Young Minds 💭

Dr. Kalam believed the true strength of India lay in its youth. He spent countless hours interacting with students, encouraging them to dream fearlessly and to pursue those dreams with discipline and determination.

His own journey — from a small town in Rameswaram to the highest office in the country — was living proof that circumstances can never define your destiny.

Despite all the fame and honors, he remained grounded and approachable. His humility was his greatest strength — and perhaps the real secret behind his success.

A Legacy That Will Never Fade 🌠

Dr. Kalam’s influence is eternal. His speeches, his books, and his vision continue to inspire young minds across India and beyond.

He didn’t just lead a nation — he ignited a generation.
He didn’t just dream of a better India — he showed us how to build it.

Dr. APJ Abdul Kalam will forever be remembered — not merely as the “Missile Man,” but as the man who taught India how to dream.

Generally, you should now use the same password almost anywhere. The creation of unique passwords per website would be highly recommended, but there would also require that you download some plugin that can store those passwords and remember them for you. So, for example, I have around 200 passwords. There’s no way I could remember them, right? I know some but some of them are truly generic and rely on platforms for me to authenticate into those sites. LastPass•••|

Storing credentials in unencrypted form on a computer, for example in your internet browser, is not the smartest idea on the planet. Probably you should do is use LastPass•••| or find an application, that can store them securely for you and has two-factor authentication.

Two-factor is probably the most secure authentication the general public can get today. Highly recommended. The main reason is that it combines something you have and something you know. What you know is your password, and what you have is usually, for example, a token on your phone. And it’s very hard to break for an average attacker. Storing anything on your device–mobile device or computer–in an unencrypted form that has your private data, either social or private life data is not a good idea.

Most people probably think of math as being about numbers and equations and, I don’t know, triangles. But where do numbers and triangles come from? Like, why are these things that anyone ever needs to talk about? You know, every math student ever has probably at some point though, math class is boring and stupid and when am I ever going to use this? Besides which, how do we know that math is true? Why do four plus three turn out to be seven instead of twelve, and how does that kind of truth relate to scientific truth, which is based on evidence rather than I guess, pure Vulcan logic?

I think most mathematicians are probably with Plato on this. They’d tell you the mathematical truth is more pure and essential and fully known than anything in science. you’ve probably heard that evolution is just a theory, even gravity is just a theory because science can’t ever fully prove anything. But maths has proofs and we know for sure they’re right. But why is science stuck defending theories about the imperfect real world while maths has these perfect truths? Plato’s idea was that there are these ideal forms, like perfect circles, which exist in a kind of maths heaven somewhere. And the things in maths heaven work as maths does and we keep realizing they exist when we see the regular world struggling to imitate them with its imperfect triangles and circles. I’m not being very fair to this idea, because to me it just sounds crazy. I mean if ideal forms don’t exist somewhere in the physical universe then isn’t the notion of their reality a metaphor? And if so, what’s it a metaphor for? Are ideal forms of the property of nature, or do they exist in our minds, or what? There are a bunch of other ideas. The intuition viewpoint says that the source of mathematical truth is human intuition; that we verify the truth of mathematical propositions subjectively by thinking through them and directly experiencing their truth.

Well, I don’t know about you, but I have an annoying tendency to directly experience the truth of things that turn out to be false! So, how do we deal with that? And then there’s the social constructionist view that mathematics is just a kind of language game that mathematicians play with one another, making up the rules as they go along like some super nerdy version of Calvin ball. Like, the only reason four plus three is seven is that everybody says so. As a kid, did you ever just keep asking why, why, why, and eventually your parents or whoever would break down and say “because I said so”? maybe that was the answer! I love to mock social constructionists but there’s a valid, important point here that the consensus of mathematicians, like any human agreement, is to some extent vulnerable to mass allusions and groupthink and all the usual in-group/out-group drama that pervades human social life.

Still, if it’s strictly true that there’s little or no connection to any underlying reality, then it’s really weird that the rules mathematicians have happened to agree on are so great for describing the world around us. And I think that’s pretty much the average scientist’s view of mathematics: It some kind of language of nature. You need it to describe how the universe acts and who cares why it works? We’ve found that it does. At least here we’re on familiar territory for scientists. Mathematical truth if nothing else is backed up by empirical observations of the world just like any scientific theory. But does that mean that mathematical proof isn’t proof? When we want to know whether a mathematical idea is true, do we have to go out and find a relevant example triangle, or an unaccountably infinite set, and confirm the theory describes something in nature? Okay, so obviously I don’t buy any of these arguments, so here’s what I think: I got this idea from Haskell Curry, an all-around awesome mathematician who outlined it in a little paper in 1951. I’m not sure Curry did a great job defending his idea from hostile philosophers, but he characterized math in a way that, at least for me, finally clarifies this vague hunch humanity has had for so long that mathematical reasoning is somehow valid. Besides observing perfect circles, there’s another very physical and empirical way that we interact with math. We perform calculations and we observe their results. What Curry thought, and what I think, is that maths is a science on the same footing as physics or chemistry. Mathematical rules themselves are phenomenon that exists in the real world and can be observed and studied. There may not be any perfect circles, but they're certainly are real definitions of them in the rules of geometry. And following the rules of geometry to reach conclusions about their properties is a real phenomenon with observable results.

Maths, in other words, is the science that studies the implications of systems of rules. And any rules count: maths is not just the stuff taught in grade school, like the straight edge and compass rules of geometry, or the equation-balancing rules of algebra, but also non-euclidean geometries and exotic algebras with arbitrary numbers of operations that are commutative or not or distributive whichever way, and the rules of games like tic-tac-toe and chess, even the abstracted rules of grocery checkout lines or stock options or gravity or quantum mechanics. Even straightforward rules can have surprising implications, so it’s not like there’s nothing to discover just because you know the rules. The Pythagoreans, for example, were scandalized to learn that the rules of geometry led undeniably to irrational numbers like the square root of two. But there it is, and we have proof. A proof that is, if you look at it another way, a reproducible experiment. Maybe we can’t prove things in maths anymore than in science, but by following the rules of geometry, we can show ourselves again and again that the hypotenuse of a right triangle with two sides of equal length can’t be the ratio between any two whole numbers. So in the science of mathematics, the hypotheses are ideas we have about the implications of rules, like “you can guarantee a draw against any opponent in tic-tac-toe just by playing well”, and then experiments are individual applications of the rules, like checking a proof, to verify that they play out in a certain way.

The experiments in maths, in other words, are computations Like the intuition idea that maths is founded in the activity of human brains computing an answer, Curry’s view focuses on the empirical observation of computations. But the idea isn’t to directly experience their intuitive truth, so much is to see that the faithful application of rules does indeed lead to a particular conclusion. Putting computation at the center of mathematics like this makes me wonder about the connection between maths and computer science. I think maths is the science of computation. After all, the deep connection between mathematical proof and commutable, which was discovered as part of the investigation into the foundations of maths in the early twentieth century, is what kicked off the field of theoretical computer science in the first place. Somebody in computer science, maybe Edsger W. Dijkstra, is supposed to have said that computer sciences are no more about computers than astronomy is about telescopes. If throughout history mathematicians used their brains to conduct mathematical experiments in the same way that astronomers observed the night sky with their naked eyes, then computers are like telescopes through which we can better investigate the computational nature of reality. But what about that kid asking “when am I ever gonna use this?” If nature is all computational and mathematical, shouldn’t math be useful? Well, of course, it is.

Maths is everywhere. When kids ask “when am I ever going to use this,” what they mean is “you’re explaining this so badly that I don’t even know what it is. You’ve taught me how to swim without ever showing me a body of water big enough to swim in.” We give them little buckets, like contrived “a train leaves Chennai Central” problems, and then drill them endlessly on techniques for solving these non-problems. Traditional math classes are so eager to cover every clever technique in a subject that we end up covering them all using boring little problems that nobody needs to solve, and we leave people confused about why they learned to solve them in the first place, which they promptly forget how to do anyway. If we covered fewer techniques, we’d have more time to tackle real problems, and kids would have a chance to get an idea of what math is. Or, at least, what it’s good for.