DEV Community: vishwa v

object(remaining topics)

vishwa v — Tue, 14 Jul 2026 13:46:00 +0000

JavaScript Properties
You can access object properties in these ways:

Dot notation
Bracket notation
Expression

Dot Notation

objectName.propertyName
person.firstname + " is " + person.age;

Bracket Notation

objectName["propertyName"]
person["firstname"] + " is " + person["age"];

In general, dot notation is preferred for readability and simplicity.

Bracket notation is necessary in some cases:

The property name is stored in a variable:
person[myVariable]

The property name is not a valid identifier:
person["last-name"]

Bracket notation is useful when the property name is stored in a variable:

let n1 = "firstName";
let n2 = "lastName";

let name = person[n2] + " " + person[n2];

Constructor

It called automatically when object is created.

the name should be start with uppercase.

Initializing object specfic value.

THIS refer to current object

(.) is differentiate value and object

Example:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        const hp=new Laptop(40000,"hp",512);
        const lenova=new Laptop(50000,"lenova",1000);
        const asus=new Laptop(30000,"asus",262);

        function Laptop(price,brand,storage){
            this.price=price;
            this.brand=brand;
            this.storage=storage;
        }
        console.log(lenova);
        console.log(hp);
        console.log(asus);
    </script>

</body>
</html>

CRUD operations in JavaScript Objects

Create (Add new property)
You can create an object or add new properties to an existing object.

// Create object using literal
const student = { name: "Saran", age: 21 };

// Add new property
student.course = "Web Development";
console.log(student); 
// { name: "Saran", age: 21, course: "Web Development" }

2. Read (Access property values)
You can read values using dot notation or bracket notation.

console.log(student.name);       // Dot notation → "Saran"
console.log(student["course"]);  // Bracket notation → "Web

3. Update (Modify property values)
Update existing properties by reassigning values.

student.age = 22; 
student.course = "JavaScript"; 
console.log(student); 
// { name: "Saran", age: 22, course: "JavaScript" }

4. Delete (Remove property)
Use the delete keyword to remove properties.

delete student.course;
console.log(student); 
// { name: "Saran", age: 22 }

object-2

vishwa v — Mon, 13 Jul 2026 16:19:22 +0000

JavaScript Object Methods
Objects can also have methods.

Object methods are actions that can be performed on objects.

Object methods are function definitions stored as property
values:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        const mobile1={
            name:"Nothing",
            price:35000,
            storage:126,
            browse:function(){
                console.log("4g speed");
            }
        }
        const mobile2={
            name:"vivo",
            price:25000,
            storage:256,
            browse:function(){
                console.log("5g speed");
            }
        }
        mobile1.browse();
        mobile2.browse();
        console.log(mobile1.name);

    </script>

</body>
</html>

In an object method, this refers to the object.

Javascript(object)

vishwa v — Sun, 12 Jul 2026 13:20:41 +0000

Intro
Objects are variables that can store both values and functions.

Values are stored as key:value pairs called properties.

Functions are stored as key:function() pairs called methods

Object Example

const car = {
  type: "Fiat",
  model: "500",
  color: "white"
};

An object literal "literally" describes an object using a concise syntax with zero or more key:value pairs inside curly braces to describe all the object properties:

{firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"}

Function(expression,arrow)

vishwa v — Fri, 10 Jul 2026 10:48:14 +0000

What is a Function Expression?
A function expression is a function stored in a variable.

// Standard Function
function multiply(a, b) {
  return a * b;
}

// Function Expression
const multiply = function(a, b) {
  return a * b;
};

Anonymous Functions
Function expressions are commonly used to create anonymous functions.

The function above is actually function without a name.

Functions stored in variables do not need names.

The variable name is used to call the function.

Functions vs. Function Expressions
JavaScript functions are defined with the function keyword.

JavaScript functions can be defined in different ways.

In JavaScript, function declarations and function expression refer to different ways of defining functions, their different syntax and how they are handled:

They both work the same when you call them.

The difference is when they become available in your code.

Hoisting
Function declarations can be called before they are defined.

Function expressions can not be called before they are defined.

Function declarations are "hoisted" to the top of their scope. This means you can call a function before it is defined in the code:

let sum = add(2, 3); // Will work

function add(a, b) {return a + b;}

Function expressions are not hoisted in the same way as function declarations.

They are created when the execution reaches their definition, and cannot be called before that point:

let sum = add(2, 3); // ⛔ Will generate error

const add = function (a, b) {return a + b;};

JavaScript Arrow Functions
Arrow Functions allow a shorter syntax for function expressions.

You can skip the function keyword, the return keyword, and the curly brackets:

const multiply = (a, b) => a * b;

If the function body contains only one statement:

You can remove the word function, the curly brackets and the return keyword.

Arrow functions are not hoisted.

Javascript (Function)

vishwa v — Thu, 09 Jul 2026 13:39:30 +0000

Introduction
Functions are reusable code blocks designed to perform a particular task.

Functions are executed when they are called or invoked.

Functions are fundamental in all programming languages.

Functions are defined with the function keyword:

followed by the function name

followed by parentheses ( )

followed by brackets { }

The function name follows the naming rules for variables.

Optional parameters are listed inside parentheses: ( p1, p2, ... )

Code to be executed is listed inside curly brackets: { }

Functions can return an optional value back to the caller.

Local Variables

Variables declared within a JavaScript function, become LOCAL to the function.

Local variables can only be accessed from within the function.

Why Functions?
Functions enable better code organization and efficiency.

With functions you can reuse the same code many times.

The same code, with different input, can produce different results.

Invoking JavaScript Functions

A JavaScript function runs when it is called.

To call a function, write the name followed by parentheses like name().

Example:

function sayHello() {
  return "Hello World";
}

let greeting = sayHello();

Calling vs Referencing a Function
This is an important difference:

sayHello refers to the function itself. It returns the function.

sayHello() refers to the function result. It returns the result.

JavaScript Function Return
A function can return a value back to the code that called it.

The return statement is used to send a value out of a function

JavaScript Function Parameters
Parameters allow you to pass (send) values to a function.

Parameters are listed inside the parentheses in the function definition.

Functions with One Parameter

function sayHello(name) {
  return "Hello " + name;
}

let greeting = sayHello("John");

Functions with Multiple Parameters

function fullName(firstName, lastName) {
  return firstName + " " + lastName;
}

let name = fullName("John", "Doe");

JavaScript Function Arguments
Parameters vs. Arguments
In JavaScript, function parameters and arguments are distinct concepts:

Parameters are the names listed in the function definition.

Arguments are the real values passed to, and received by the function.

function multiply(a, b) {
  return a * b;
}

let result = multiply(4, 5);

In this
a and b are parameters
4 and 5 are arguments
The argument 4 is assigned to the parameter a.

The argument 5 is assigned to the parameter b

For loop

vishwa v — Wed, 08 Jul 2026 14:20:04 +0000

For Loops can execute a block of code a number of times.

<script>
        for(i=1;i<=5;i++){
            console.log(i)
        }
    </script>

do
The do while loop is a variant of the while loop. This loop will execute the code block once, before checking if the condition is true, then it will repeat the loop as long as the condition is true

While Loop

vishwa v — Tue, 07 Jul 2026 15:22:33 +0000

The while loop loops through a block of code as long as a specified condition is true.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        let i=1
        while(i<=5)
    {
        console.log("hi")
        i++;
    }

    let j=1
    while(j<=5){
        console.log(j)
        j++;
    }

    let k=1
    while(k<=10){
        console.log(k)
        k+=2;
    }

    let q=1
    while(q<=15){
        if(q%3==0){
            console.log(q)
        }
        q++;
    }



    let m=1
    while(m<=50){
        if(m%3==0 && m%5==0){
            console.log(m)
        }
        m++;
    }

    let l=1
    while(l<=50){
        if(l%3==0 || l%5==0){
            console.log(l)
        }
        l++;
    }

    </script>

</body>
</html>

Contitional Property

vishwa v — Mon, 06 Jul 2026 16:20:36 +0000

JavaScript if
Use the JavaScript if statement to execute a block of code when a condition is true.

if (hour < 18) {
  greeting = "Good day";
}

Nested if
You can use an if statement inside another if statement:

let age = 16;
let country = "USA";
let text = "You can Not drive!";

if (country == "USA") {
  if (age >= 16) {
    text = "You can drive!";
  }
}

The else Statement
Use the else statement to specify a block of code to be executed if a condition is false.

JavaScript Ternary Operator
The conditional operator is a shorthand for writing conditional if...else statements.

It is called a ternary operator because it takes three operands.

let text = (age < 18) ? "Minor" : "Adult";

JavaScript Switch Statement
switch is often used as a more readable alternative to many if...else if...else statements, especially when dealing with multiple possible values.

switch (new Date().getDay()) {
  case 0:
    day = "Sunday";
    break;
  case 1:
    day = "Monday";
    break;
  case 2:
     day = "Tuesday";
    break;
  case 3:
    day = "Wednesday";
    break;
}

When JavaScript reaches a break keyword, it breaks out of the switch block.
This will stop the execution inside the switch block.

The default Keyword
The default keyword specifies a block of code to run if there is no case match.

JavaScript Booleans
In JavaScript, a Boolean is a primitive data type that can only have one of two values:

true or false

The Boolean value of an expression is the basis for all JavaScript comparisons and conditions.

CSS (property

vishwa v — Sun, 05 Jul 2026 07:57:45 +0000

1.Z-index
The z-index property specifies the stack order of positioned elements.

The stack order defines which element should be placed in front or behind other elements.

When elements are positioned, they can overlap other elements.

An element can have a positive or negative stack order (z-index):

Example

<!DOCTYPE html>
<html>
<head>
<style>
img {
  position: absolute;
  left: 0px;
  top: 0px;
  z-index: -1;
}
</style>
</head>
<body>

<h1>This is a heading</h1>
<img src="img_tree.png">
<p>Because the image has a z-index of -1, it will be placed behind the text.</p>

</body>
</html>

2.overflow
The CSS overflow property controls what happens to content that is too big to fit into an area.

It specifies whether to clip the content or to add scrollbars when the content of an element is too big.

The overflow property has the following values:

visible - Default. The overflow is not clipped. The content renders outside the element's box
hidden - The overflow is clipped, and the rest of the content is hidden
scroll - Scrollbars are added. User must scroll to see all content
auto - Similar to scroll, but adds scrollbars only when necessary

div {
  width: 200px;
  height: 65px;
  background-color: coral;
  overflow: visible;
}

3.float
The float property specifies how an element should float within its container.

It places an element on the left or right side of its container, allowing text and inline elements to wrap around it.

The float property can have one of the following values:

left - The element floats to the left of its container
right - The element floats to the right of its container
none - Default. The element does not float and is displayed just where it occurs in the text
inherit - The element inherits the float value of its parent

img {
  float: left;
}

CSS @keyframes Rule
Rule is used to control the steps in an animation sequence by defining CSS styles for points along the animation sequence.

@keyframes mymove {
  0%   {top: 0px;}
  25%  {top: 200px;}
  50%  {top: 100px;}
  75%  {top: 200px;}
  100% {top: 0px;}
}
   OR

div {
  width: 100px;
  height: 100px;
  background: red;
  position: relative;
  animation: mymove 5s infinite;
}

@keyframes mymove {
  0%   {top: 0px; left: 0px; background: red;}
  25%  {top: 0px; left: 100px; background: blue;}
  50%  {top: 100px; left: 100px; background: yellow;}
  75%  {top: 100px; left: 0px; background: green;}
  100% {top: 0px; left: 0px; background: red;}
}

CSS @media Rule
The CSS @media rule is used in media queries to apply different styles for different media types/devices.

Media queries can be used to check many things, such as:

width and height of the viewport
width and height of the device
orientation (is the tablet/phone in landscape or portrait mode?)
resolution

body {
  background-color: lightblue;
}

@media screen and (min-width: 400px) {
  body {
    background-color: lightgreen;
  }
}

@media screen and (min-width: 800px) {
  body {
    background-color: lavender;
  }
}

CSS animation Property

div {
  animation: mymove 5s infinite;
}

The animation property is a shorthand property for:

animation-name
animation-duration
animation-timing-function
animation-delay
animation-iteration-count
animation-direction
animation-fill-mode
animation-play-state

CSS opacity Property
The opacity property sets the opacity level for an element.

The opacity-level describes the transparency-level, where 1 is not transparent at all, 0.5 is 50% see-through, and 0 is completely transparent

div {
  opacity: 0.5;
}

Library management system

vishwa v — Sun, 05 Jul 2026 07:15:40 +0000

"I built a Library Management System — a web application that lets an admin manage books, members, and track book issue/return transactions."

2. Mention the tech stack (shows technical depth)

"I used Java with Spring Boot for the backend, MySQL as the database, Thymeleaf for rendering the frontend pages, and JavaScript for form validation and live search."

3. Explain the architecture (shows you understand structure, not just code)

"I followed the MVC pattern — Spring Data JPA handles communication with MySQL, the Controller layer processes requests and business logic, and Thymeleaf renders the final HTML that's sent to the browser. This is server-side rendering, meaning the backend builds the complete page before sending it, rather than using a separate frontend framework like React."

4. Walk through the core features

"The system has three main entities — Books, Members, and Transactions. An admin can add, edit, or delete books, register members, and issue or return books. When a book is issued, the system checks if copies are available, decreases the count, and creates a transaction record linking that book and member. When it's returned, the available count goes back up and the transaction is marked complete."

5. Mention the database design (common follow-up question)

"I used three related tables — books, members, and transactions — with transactions acting as a linking table using foreign keys. I chose MySQL over something like MongoDB because the data has clear relationships that a relational database handles naturally."

6. Mention a challenge you solved (this is what interviewers actually want to hear)

"One thing I had to handle carefully was preventing a book from being issued when there are zero available copies — so I added a check in the service layer before allowing the transaction to go through."

(Once you actually build it, replace this with a REAL challenge you personally hit and fixed — interviewers can tell when this is rehearsed vs. real.)

7. Close with what you learned/took away

"This project helped me understand full-stack development end-to-end — from database design and backend logic to connecting it with a working frontend."

what is thymeleaf

"I used Thymeleaf for server-side rendering — my Spring Boot backend fetches data from MySQL and builds the complete HTML page before sending it to the browser, rather than using a separate frontend framework that calls a REST API."

Problem Statement

"Many small libraries — like college department libraries or community libraries — still manage book records, member details, and issue/return activity manually using registers or spreadsheets. This leads to several issues:

No easy way to check if a book is available without physically searching
Difficult to track which member currently has which book, and since when
No system to prevent issuing a book that has zero copies left
Manual searching is slow, especially as the number of books grows
Risk of human error — lost records, incorrect entries, no backup

The Library Management System solves this by digitizing the entire process — providing a centralized system where an admin can manage books, register members, and track issue/return transactions accurately and efficiently, eliminating manual record-keeping."

Que

1. Why Spring Boot?
Spring Boot is a popular Java tool that makes backend coding faster and easier. It handles a lot of setup work automatically, so I write less code and focus on the actual features.

2. What is MVC?
MVC splits the project into 3 parts so things stay organized:

Model = the data (Book, Member, Transaction)
View = what the user sees (the HTML pages)
Controller = the middleman that connects the two

3. Why is transactions a separate table?
Because one book can be issued and returned many times by different people. If I stored that info inside the books table, I'd lose the old history every time. A separate table keeps a full record of every issue/return event.

4. How does Spring Data JPA help?
Normally you'd have to write SQL yourself to get data from MySQL. With Spring Data JPA, I just write a simple Java method name like findByAuthor, and it automatically creates the SQL for me. Less code, fewer mistakes.

5. The tricky part — let me explain this one simply first:
The problem: Imagine a book has 0 copies left, but the system still allows someone to issue it. That's wrong — you can't lend a book that isn't available.
The fix: Before issuing any book, the system checks: "Does this book have at least 1 copy available?"

If yes → allow the issue, reduce the count by 1
If no → block it and show an error like "No copies available"

Why this is "tricky": It's not enough to just hide the "Issue" button on the webpage — a smart user could still try to force the request another way. So the check has to happen in the backend (the real brain of the app), not just the frontend (what the user sees). That way, the rule is actually enforced, not just visually hidden.
Simple way to say this in an interview:

"I made sure a book can't be issued if there are zero copies left. I added this check on the backend, not just the frontend, so the rule can't be bypassed."

diff

Thymeleaf → If you want the backend to generate complete HTML pages (classic MVC apps).

REST → If you want the backend to serve raw data for multiple clients (web, mobile, etc.).

Fetch API → If your frontend (browser) needs to call REST endpoints and dynamically update the UI.

In short: Thymeleaf = server-side views, REST = backend APIs, Fetch = client-side calls to APIs.

mock interview-2(medigpt)

vishwa v — Sat, 04 Jul 2026 15:55:27 +0000

How did you reduce Hallucination?

Hallucination was reduced using Fact-Grounded Distillation Objective (FGDO).

Standard models optimize for fluent text only.

FGDO adds a penalty when generated facts contradict or aren’t supported by UMLS (a trusted medical knowledge base).

This forces the model to prefer factually grounded outputs over plausible-sounding but false ones.

As a result, it achieved higher factual accuracy than BioGPT and GPT-Neo.

What is Hallucination?
AI models sometimes make up medical facts confidently — called hallucination. In healthcare, a wrong fact can literally harm someone. So your project's goal: build a medical AI that doesn't lie.

What is fine-tuning here?

After MediGPT is pre-trained (decoder-only, GPT-style, on the biomedical corpus), it goes through supervised fine-tuning using FGDO — this is the stage where the dual-loss (cross-entropy + factual loss) is applied, using AdamW optimizer, a warmup + cosine decay learning rate schedule, gradient clipping, and FP16 mixed-precision training.

example:
Without FGDO (just fluent text):

"Asthma is caused by eating spicy food."

→ Sounds plausible, but it’s factually wrong.

With FGDO (fact-grounded via UMLS):

"Asthma is a chronic condition where the airways become inflamed and narrow, often triggered by allergens or exercise."

→ This matches medical knowledge and avoids unsupported claims.

So FGDO acts like a fact-checking filter during training — penalizing unsupported statements and rewarding medically accurate ones.

Vector Database

Stores UMLS facts as embeddings so the system can quickly find the closest matching medical fact to verify what the model said.

UMLS = Unified Medical Language System, a big trusted database of medical terms, concepts, and relationships (like a giant medical dictionary + knowledge graph). "UML" (no S) is a totally different thing — a software design diagram notation. In your project, you mean UMLS embedding.

What is a UMLS embedding?
An embedding is just a way of turning text into a list of numbers (a vector) that captures its meaning, not just its spelling. Similar meanings → similar numbers.

So a UMLS embedding means: taking each medical concept/fact from UMLS (e.g., "Metformin treats Type 2 Diabetes") and converting it into a numerical vector that represents its meaning.

React
A chat-style UI where users type medical questions and get answers with a disclaimer to consult healthcare professionals. React would be the natural choice to build that client-side chat UI — handling message state, rendering conversation history, and making calls (via Fetch API, tying back to your earlier question) to your backend/model API to get responses.

GPT — Full form
Generative Pre-trained Transformer — and MediGPT's architecture is decoder-only, following this GPT family design, since decoder-only models suit autoregressive generation (ideal for summarization, report generation, medical Q&A).

MediGPT uses this decoder-only architecture (predicts text word-by-word).

One-liner for interviews:
"I built a medical AI and created FGDO — a training method that checks facts against a trusted medical database using vector search, and penalizes the model for wrong answers, making it more reliable than RAG-based or plain fine-tuned models."

The Problem
AI models sometimes make up medical facts confidently — called hallucination. In healthcare, a wrong fact can literally harm someone. So your project's goal: build a medical AI that doesn't lie.

What is MediGPT?
A custom AI language model (like ChatGPT, but decoder-only GPT-style architecture) specifically trained for medical/clinical text — answering health questions, summarizing clinical notes, etc.

Step 1: Data
Trained using real medical text:

PubMed — medical research papers
MIMIC-III/IV — real (anonymized) ICU patient records
UMLS — a trusted medical knowledge base (used to check facts, not as training text)
MedQuAD / MIMIC-IV-Ext-BHC — used to create practice questions during training

Step 2: Custom Tokenizer
Normal AI models break medical words like "electroencephalogram" into weird chopped-up pieces. You built a custom tokenizer (BPE) trained on medical text so complex terms are understood as single, clean units — more efficient and accurate.

Step 3: Model Architecture
Decoder-only Transformer (same family as GPT) — good at generating text step-by-step. Also uses ALiBi, a technique that helps it handle very long clinical documents without losing track of context.

Step 4: The Big Innovation — FGDO
This is your main contribution, and it's how you reduce hallucination:

Model answers a question

The answer is broken into small individual facts.

Each fact is checked against UMLS (using a vector database for similarity search — matching the fact's meaning to trusted medical entries).

If a fact is false or unverifiable → penalty. If true → no penalty (or reward).

This penalty ("factual loss") is added to normal training loss, so the model is directly trained to avoid making things up — not just fine-tuned to sound fluent.

RAG vs FGDO — the key distinction

RAG = look up facts at answer-time and hand them to the model as a cheat sheet. Doesn't fix the model itself.

FGDO = teach the model during training to stop making false claims. Fixes the model's actual behavior.
Your project uses FGDO, not RAG — that's the novel part.

The App
A React-based chat interface (like a chatbot) where users ask medical questions and get answers — always with a disclaimer to consult a real doctor.

Results
Compared to BioGPT and GPT-Neo, MediGPT scored higher on:

ROUGE-1 & ROUGE-L (text quality/similarity to correct answers)
Factual Accuracy (0.95 vs 0.85 and 0.77)

Ethics built in

Never replaces doctors — just assists ("human-in-the-loop")
Follows HIPAA/GDPR for patient privacy
Flags uncertainty instead of guessing when unsure
Checked for bias across different patient groups

One-line summary you can say in an interview:
"I built a medical AI model and proposed a new training method called FGDO, which checks the model's facts against a trusted medical database during training and penalizes it for wrong information — making it more factually reliable than existing models like BioGPT, without depending on RAG."

operators

vishwa v — Fri, 03 Jul 2026 15:46:07 +0000