1. Zero-Shot Prompting

Imagine: Asking your assistant to do something without showing any examples.

Example:

Translate this sentence into Punjabi: "How are you today?"

• → Output: "ਤੁਸੀਂ ਅੱਜ ਕਿਵੇਂ ਹੋ?"

  • Benefit: Fast, simple, relies on model pretraining.

  • Best for: General translation, summarization, classification.

2. Instruction Prompting

Imagine: Giving clear, structured instructions so the assistant knows exactly what to do.

Example:

Instruction: Summarize the following paragraph into one sentence.
Input: Artificial intelligence is rapidly changing industries by automating tasks, improving decision-making, and enhancing personalization.

→ Output: AI is transforming industries through automation, decision-making, and personalization.

• Benefit: Clear guidance improves output accuracy without examples.

• Best for: Chatbots, customer support, general LLM tasks.

3. Few-Shot / In-Context Learning (aka K-Shot Prompting)

Imagine: Showing your assistant a few examples so it can learn the pattern.

Example (Movie Reviews):

Review 1: "I loved this movie!" → Positive
Review 2: "It was boring." → Negative
Review 3: "The acting was fantastic, but the plot was dull." →

→ Output: Mixed / Negative

• Benefit: Teaches patterns or styles quickly without retraining.

• Best for: Pattern replication, domain-specific adaptations.

4. Chain-of-Thought (CoT) Prompting

Imagine: Asking the assistant to think step by step.

Example:

If you have $50, spend $20 on groceries and $10 on gas, how much is left? Think step by step.

→ Output: You start with $50. After spending $20 on groceries, $30 remain. After spending $10 on gas, $20 remain.

• Benefit: Structured reasoning improves answers for logic or math.

• Optional enhancement: Self-Consistent CoT – generate multiple reasoning paths, then pick the most consistent answer.

5. Step-Back Prompting

Imagine: Before answering, your assistant pauses to identify the main ideas.

Example:

Before writing a cake recipe, list all ingredients and steps needed.

→ Output: Lists flour, sugar, eggs, baking powder, etc., and stepwise process.

• Benefit: Produces big-picture reasoning.

• Best for: Planning, structured tasks, or preparation.

6. Least-to-Most Prompting

Imagine: Solving complex problems by starting with easier steps first.

Example:

Organize my study schedule:
Step 1: List all subjects.
Step 2: Prioritize by difficulty.
Step 3: Assign days and times.

→ Output:

Subjects: Math, History, Science, English

Prioritized: Math (hard), Science (medium), History (medium), English (easy)

Schedule: Mon–Math, Tue–Science, Wed–History, Thu–English

• Benefit: Reduces mistakes in multi-step reasoning.

• Best for: Study planning, scheduling, or problem decomposition.

7. Tree-of-Thought (ToT)

Imagine: The assistant explores multiple reasoning paths simultaneously, like branches of a tree, then chooses the best path.

Example:

Choose a vacation destination: consider cost, activities, and weather across multiple options simultaneously, then pick the best combination.

→ Output:

Path 1: Paris → great culture, but expensive.

Path 2: Bali → affordable, good weather, fun activities.

Path 3: New York → lots to do, but crowded in summer.

Final choice: Bali for balance of cost, weather, and activities.

• Benefit: Improves accuracy on complex, multi-step reasoning tasks.

• Best for: Multi-hop questions, strategic planning, or decision-making.

8. Prompt Chaining

Imagine: Breaking a big task into smaller sequential tasks, where output from one becomes input to the next.

Example:

Step 1: Identify customer complaints.
Step 2: Categorize them (billing, delivery, product quality).
Step 3: Suggest solutions for each category.

→ Output:

Complaints: “Late package,” “Overcharged,” “Broken item.”

Categories: Delivery → “Late package”; Billing → “Overcharged”; Product → “Broken item.”

Solutions: Delivery → Faster shipping; Billing → Refund; Product → Replace item.

• Benefit: Handles long workflows or multi-stage reasoning efficiently.

• Best for: Multi-step instructions, report generation, support workflows.

9. Role-Playing

Imagine: Asking your assistant to pretend to be a famous person or expert to give advice.

Example:

You are Warren Buffett, the most successful investor.
Advise me on how I should invest my paycheck into stocks, focusing on long-term growth and safety.

→ Output: Invest in S&P 500 index funds, focusing on long term growth.

• Benefit: Adopts tone, style, or expertise for more natural, authoritative outputs.

• Best for: Teaching, mentorship simulations, expert advice, or role-specific guidance.

10. Long-Form / Detailed Prompting

Imagine: Giving rich, detailed instructions for structured outputs.

Example:

Write a short story (around 800 words) for a 12-year-old audience about aliens landing on Earth and befriending humans. The story should:

• Be funny, adventurous, and uplifting.

• Include at least 3 main characters (2 human kids and 1 alien).

• Teach a lesson about teamwork and kindness.

• Use simple language a middle schooler can easily follow.

• Have a beginning (arrival of the aliens), middle (the challenge they face together), and ending (how friendship solves the problem).
  Format it with paragraphs and dialogue between the characters.

• Benefit: Produces well-structured, engaging, and imaginative outputs.

• Best for: Creative writing, tutoring, simulations, or storytelling.

Quick Strength Table

Using these techniques is like choosing the right painting tool for the job.

• If you’re painting a small table, a brush is perfect.

• If you’re painting part of a wall, a roller works best.

• But if you’re painting an entire house, a sprayer is the fastest and most effective.

Prompting works the same way, the right technique makes the task easier, faster, and produces a better result.

I would love to hear what technique you use the most and which one you are going to start trying out in the comments.

Applications have used traditional databases for a long time with evolutions including NoSQL and big data but are less applicable in today’s modern applications. Traditional databases are monolithic and require human-computer interaction where the database sits passively unless triggered by a query. Modern applications are entirely automated and streamlined following an event streaming process where the data is active and is triggered by events creating a chain of processes fulfilling a business need.

In 2010 LinkedIn developed Kafka, an open-source distributed event streaming platform that captures data in real-time from databases, sensors, mobile devices, and cloud services for manipulating, processing, reacting to event streams, and routing for a continuous flow of data. Currently, multiple companies are using Kafka including Uber, Netflix, and Slack to fulfill their business needs.

What are the uses of Kafka

Kafka’s main uses are to read, write, store, and process streams of events reliably for as long as you want and as they occur. A few great benefits include speed, fault tolerance via backup servers and scalability due to data being spread across partitions. Some real-world examples include monitoring vehicles, routing, and processing payments at Uber, Lyft, and Airbnb. Other applications of event streaming include collecting and immediately reacting to customer interactions and orders in the retail, hotel, and travel industries. Kafka can be deployed on virtual machines, containers, the cloud and even hardware making it versatile and elastic.

How does Kafka work

Kafka is an exceptional microservices tool that works via a distributed system of multiple components spread across multiple computers on a network using server and client communication over TCP. It runs on sets of connected computers (clusters) of several servers through multiple datacenters or cloud regions. Each of these clusters have at least 3 brokers that are simply a Kafka server and runs an instance of the Kafka application that acts as an intermediary between applications sending messages (data) and applications receiving messages leaving no direct communication between sender and receiver.

Producers

The producer is an application that sends messages to a broker. These messages are sent in batches to increase efficiency in reducing the number of unnecessary networks and are serialized before it is sent.

Consumers

The consumer receives messages from the broker. It does not communicate with the producer directly. Similar to how the producer must serialize messages before sending it, the consumer must deserialize the messages. Consumers can consume multiple topics at once and can also split a topic into multiple partitions where multiple consumers work together to each read from a single partition.

What is Avro

Avro helps serialize the data before sending it to the brokers. In Kafka, Avro can create a schema from a Java class and helps with the data exchange between programming languages, systems, and processing frameworks. This is useful since Avro provides direct mapping to and from JSON, is fast, compact, and is accompanied by a schema.

Learn more

This article has just given a very brief introduction to a higher level understanding of Kafka. To learn more, visit the official Kafka documentation.

Javascript is a language that was developed in only 10 days. Yes, the creator Brendan Eich developed it in less than two weeks and states "It was also an incredible rush job, so there were mistakes in it - and there would be gaps". Fortunately, Javascript has been standardized via ECMAScript which built numerous core features on top of the original Javascript. ES2015 or ES6 was a huge leap in the language that brought many changes and made the language better. One of the exciting features is template literals.

Why Template Literals

Unlike using double or single quotes to express string characters, template literals use backticks (`) and can do much more than what " or ' offer. Template literals give access to do multi-line strings, interpolate expressions, and use tagged templates. They make writing code much neater and understandable compared to using only strings in simple to complex applications.

Dealing With Multi-line Strings

Before template literals, having multi-line strings was accomplished by \n. This method works well with small stings but is not as clean and readable compared to using template literals.

Without template literals:

console.log("JS History:\n" + "Javascript was originally named \"Mocha\"");
//JS History:
//Javascript was originally named "Mocha"

With template literals:

console.log(`JS History:
Javascript was originally named "Mocha"`);
//JS History:
//Javascript was originally named "Mocha"

With these two different methods of doing the same task, it is easy to understand how template literals simplify things. It eliminates the use of including \n to create a new line and enables you easily input double quotes and is displayed just as you wrote it.

Include Expressions

Using the ${} inside the (``) gives access to expressing variables, objects, strings, or even mathematical operations with other values.

let language = "Javascript";
let year = 1995;
let currentYear = 2021;
console.log(`${language} was created in ${year}. 
It has been in use for ${currentYear - year} years`);
//Javascript was created in 1995. 
//It has been in use for 26 years

Creating Tagged Templates

If you like the usability of template literals, you will be interested in an advanced form of it using tagged templates. Tagged templates give access to parse literals with a function. Tagged templates consist of two parts, one being the strings and the other, the variables being passed on. These two parts can also be referred as static content and dynamic content respectively.

For example:

let person = "Kamaljot";
function displayGreeting(strings, name){
  console.log(strings);
  console.log(name);
}
displayGreeting`Hello ${person}, it was nice meeting you`;
//['Hello ', ', it was nice meeting you']
//Kamaljot

Here we notice that the first parameter puts all the strings or static content into a single array and holds the variable or dynamic content separate. Although the dynamic content of the name variable is not in the strings array, it is represented as an empty string.

You can also include more than one dynamic content by using the spread operator ... which allows arrays and can expand them into their individual elements.

let guest1 = "Kamaljot";
let guest2 = "Simran";
function displayGreeting(strings, ...guests){
  console.log(strings);
  console.log(guests);
}
displayGreeting`Hello ${guest1} and ${guest2}, welcome to the event`;
//['Hello ', ' and ', ', welcome to the event']
//['Kamaljot', 'Simran']

Looking closer at our output, we see that our function takes two arguments and holds the static and dynamic content separately. The strings array holds all the static content consisting of strings while the names array holds all the dynamic content also referred to as tags.

To make tagged templates useful and not just output two separate arrays, we can manipulate the arguments being passed and output information in the order we desire.

let guest1= "Kamaljot";
let guest2= "Simran";
function displayGreeting(strings, ...guests){
  let message = strings[0];
  for (let i=0; i<guests.length; i++){
    message += guests[i] +strings[i+1];
  }  
console.log(message);
}
displayGreeting`Hello ${guest1} and ${guest2}, welcome to the event`;
//Hello Kamaljot and Simran, welcome to the event

Conclusion

Template literals is a powerful tool that I believe many of us can implement in our code to make it more readable and concise. The topics I have mentioned here are giving a brief introduction to some of the capabilities of template literals. Tagged templates are unique and give programmers another technique to transform content. Feel free to share your knowledge on template literals and whether you use them or not in the comment section.

The Document Object Model (DOM) is how you manipulate HTML elements of a webpage using a language like Javascript. The DOM works by treating the webpage as a tree-like structure where every HTML tag is an object and gives you access to navigate, create, alter or delete the content of HTML elements, attributes, and CSS styles.

Here is a visual representation of the objects of a DOM tree from W3Schools:

In the representation above, the structure is a collection of nodes where they have a root -> parent ->child -> sibling relationship. The <html> is the root where all other elements are descendants.

Traversing

Finding, selecting, or traversing elements are managed by creating a reference point to a specific node where you can then move downward, upward, and sideways.

Get Element By ID

The most common way is to select an id that is always unique and only returns a single element.

HTML snippet:

<h1 id="blog-title">Traverse the DOM like a PRO</h1>

Javascript snippet:

const blogTitle = document.getElementById("blog-title");
console.log(blogTitle.textContent);
// Traverse the DOM like a PRO

Get Elements by ClassName

This returns a collection of objects since more than one element can have the same class name.

HTML snippet:

...
  <li class="item">Item 1</li>
  <li class="item">Item 2</li>
  <li class="item">Item 3</li>

Javascript snippet:

const items = document.getElementsByClassName("item");
for (item of items) {
    console.log(item.textContent);
}
// Item 1
// Item 2
// Item 3

Note: getElementsByClassName does not behave like real arrays. It may not have methods like forEach, slice, some, map and must include Array.from(element) to turn into an array including those properties.

Query Selector

This is my favorite way and allows you to select either an id or the very first class of the specific class name. Defining the id or class name uses a similar syntax in which you would use in your CSS file.

Javascript snippet:

const blogTitle = document.querySelector("#blog-title");
const firstItem = document.querySelector(".item");
console.log(blogTitle.textContent);
console.log(firstItem.textContent);
// Traverse the DOM like a PRO
// Item 1

Query Selector All

If you need to modify more than one element of a particular selector, this is an alternative method and my preferred method.

Javascript snippet:

const items = document.querySelectorAll(".item");
items.forEach(function(element){
    console.log(element.textContent);
})
// Item 1
// Item 2
// Item 3

Selecting Children

Traversing down or selecting the children of a node can be accomplished by the children method.

const parent = document.querySelector(".parent");
const firstChild= parent.children;

Selecting the first child or last child is also possible by firstChild and lastChild methods respectively.

Selecting Parents

Traversing up or selecting the parents of a node can be accomplished by the parentElement method.

const firstChild = document.querySelector(".firstChild");
const parent = firstChild.parentElement;

One thing to note is that the parentElement method only allows you to move up one parent at a time. You can not skip a parent.

A way to resolve this is by using the closest method where we can find any specific parent element.

grandparent = child.closest(".grandparent")

Selecting Sibling Elements

If you would like to traverse a sibling of an element, you can use nextElementSibling to move forward to the next sibling.

const secondChild = firstChild.nextElementSibling;

If you want to move to a previous sibling and move backward, use previousElementSibling

const firstChild = secondChild.previousElementSibling

Conclusion

By describing multiple ways to traverse, you should now be comfortable selecting any element in a webpage. Although querySelector may be a simple way to find any element, some web pages may be extremely large and it may be better to use the sibling options instead to increase performance. Although we went over many options, there are countless more options available in traversing. To find more information, visit the MDN DOM Documentation.