People Who Code | Blog: October 2025

JavaScript + Angular-compatible version of loan amortization calculator that you can integrate into an Angular component or service

JavaScript Version of Loan Amortization

1. Loan Calculator Function (Pure JS/TS)


export function calculateLoanSchedule(
  principal: number,
  annualRate: number,
  years: number,
  extraPayment: number = 0
) {
  const monthlyRate = annualRate / 12 / 100;
  const months = years * 12;
  const monthlyPayment = 
    (principal * monthlyRate) / (1 - Math.pow(1 + monthlyRate, -months));

  const schedule = [];
  let balance = principal;
  let totalInterest = 0;
  let month = 1;

  while (balance > 0 && month <= months) {
    const interest = balance * monthlyRate;
    let principalPayment = monthlyPayment - interest + extraPayment;

    if (principalPayment > balance) {
      principalPayment = balance;
    }

    balance -= principalPayment;
    totalInterest += interest;

    schedule.push({
      month,
      payment: parseFloat((monthlyPayment + extraPayment).toFixed(2)),
      principal: parseFloat(principalPayment.toFixed(2)),
      interest: parseFloat(interest.toFixed(2)),
      balance: parseFloat(balance.toFixed(2))
    });

    month++;
  }

  const totalPaid = schedule.reduce((sum, p) => sum + p.payment, 0);
  return {
    schedule,
    totalPaid: parseFloat(totalPaid.toFixed(2)),
    totalInterest: parseFloat(totalInterest.toFixed(2)),
    totalMonths: schedule.length
  };
}

2. Example Usage in Angular Component


import { Component, OnInit } from '@angular/core';
import { calculateLoanSchedule } from './loan-calculator';

@Component({
  selector: 'app-loan-schedule',
  templateUrl: './loan-schedule.component.html',
})
export class LoanScheduleComponent implements OnInit {
  loanData: any;
  schedule: any[] = [];

  ngOnInit(): void {
    const principal = 300000;
    const annualRate = 6.0;
    const years = 30;
    const extraPayment = 200;

    this.loanData = calculateLoanSchedule(principal, annualRate, years, extraPayment);
    this.schedule = this.loanData.schedule;
    console.log('Loan Summary:', this.loanData);
  }
}

3. Optional Template Snippet


<table>
  <thead>
    <tr>
      <th>Month</th>
      <th>Payment</th>
      <th>Principal</th>
      <th>Interest</th>
      <th>Balance</th>
    </tr>
  </thead>
  <tbody>
    <tr *ngFor="let row of schedule">
      <td>{{ row.month }}</td>
      <td>{{ row.payment | currency }}</td>
      <td>{{ row.principal | currency }}</td>
      <td>{{ row.interest | currency }}</td>
      <td>{{ row.balance | currency }}</td>
    </tr>
  </tbody>
</table>

 1. Create the Service
Run this command to generate a service:
ng generate service services/loan-calculator

Or manually create:
src/app/services/loan-calculator.service.ts
import { Injectable } from '@angular/core';

export interface LoanScheduleEntry {
  month: number;
  payment: number;
  principal: number;
  interest: number;
  balance: number;
}

export interface LoanSummary {
  schedule: LoanScheduleEntry[];
  totalPaid: number;
  totalInterest: number;
  totalMonths: number;
  payoffYears: number;
  payoffMonths: number;
}

@Injectable({
  providedIn: 'root',
})
export class LoanCalculatorService {
  constructor() {}

  calculateLoanSchedule(
    principal: number,
    annualRate: number,
    years: number,
    extraPayment: number = 0
  ): LoanSummary {
    const monthlyRate = annualRate / 12 / 100;
    const totalMonths = years * 12;
    const monthlyPayment =
      (principal * monthlyRate) / (1 - Math.pow(1 + monthlyRate, -totalMonths));

    const schedule: LoanScheduleEntry[] = [];
    let balance = principal;
    let totalInterest = 0;
    let month = 1;

    while (balance > 0 && month <= totalMonths) {
      const interest = balance * monthlyRate;
      let principalPayment = monthlyPayment - interest + extraPayment;

      if (principalPayment > balance) {
        principalPayment = balance;
      }

      balance -= principalPayment;
      totalInterest += interest;

      schedule.push({
        month,
        payment: parseFloat((monthlyPayment + extraPayment).toFixed(2)),
        principal: parseFloat(principalPayment.toFixed(2)),
        interest: parseFloat(interest.toFixed(2)),
        balance: parseFloat(balance.toFixed(2)),
      });

      month++;
    }

    const totalPaid = schedule.reduce((sum, entry) => sum + entry.payment, 0);
    const monthsTaken = schedule.length;

    return {
      schedule,
      totalPaid: parseFloat(totalPaid.toFixed(2)),
      totalInterest: parseFloat(totalInterest.toFixed(2)),
      totalMonths: monthsTaken,
      payoffYears: Math.floor(monthsTaken / 12),
      payoffMonths: monthsTaken % 12,
    };
  }
}


✅ 2. Usage in a Component
src/app/components/loan.component.ts
import { Component, OnInit } from '@angular/core';
import { LoanCalculatorService, LoanSummary } from 'src/app/services/loan-calculator.service';

@Component({
  selector: 'app-loan',
  templateUrl: './loan.component.html',
})
export class LoanComponent implements OnInit {
  loanSummary!: LoanSummary;

  constructor(private loanCalculator: LoanCalculatorService) {}

  ngOnInit(): void {
    const principal = 300000;
    const annualRate = 6.0;
    const years = 30;
    const extraPayment = 200;

    this.loanSummary = this.loanCalculator.calculateLoanSchedule(
      principal,
      annualRate,
      years,
      extraPayment
    );

    console.log(this.loanSummary);
  }
}


✅ 3. Template Example (loan.component.html)
<h2>Loan Summary</h2>
<p>Total Paid: {{ loanSummary.totalPaid | currency }}</p>
<p>Total Interest: {{ loanSummary.totalInterest | currency }}</p>
<p>Loan Paid Off In: {{ loanSummary.payoffYears }} years and {{ loanSummary.payoffMonths }} months</p>

<table>
  <thead>
    <tr>
      <th>Month</th>
      <th>Payment</th>
      <th>Principal</th>
      <th>Interest</th>
      <th>Balance</th>
    </tr>
  </thead>
  <tbody>
    <tr *ngFor="let row of loanSummary.schedule">
      <td>{{ row.month }}</td>
      <td>{{ row.payment | currency }}</td>
      <td>{{ row.principal | currency }}</td>
      <td>{{ row.interest | currency }}</td>
      <td>{{ row.balance | currency }}</td>
    </tr>
  </tbody>
</table>

complete SQL Server guide with queries from start to end covering how to create tables, add/drop columns, insert/update/delete data, and manage advanced features like constraints, indexes, and stored procedures. This is your go-to reference for working with SQL Server

🧱 1. Create Table

sql

CREATE TABLE Employee (

    EmpId INT PRIMARY KEY,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    DOB DATE,
    Salary DECIMAL(18,2)
);


2. Add Columns
sql
ALTER TABLE Employee
ADD Department VARCHAR(50),
    JoiningDate DATE;
🧹 3. Drop Columns
sql
ALTER TABLE Employee
DROP COLUMN JoiningDate

 4. Modify Column Data Type
sql
ALTER TABLE Employee
ALTER COLUMN Salary FLOAT;
📥 5. Insert Data
sql
INSERT INTO Employee (EmpId, FirstName, LastName, DOB, Salary, Department)
VALUES (101, 'John', 'Doe', '1990-05-15', 75000, 'HR');
🧾 6. Update Data
sql
UPDATE Employee
SET Salary = 80000
WHERE EmpId = 101;
❌ 7. Delete Data
sql
DELETE FROM Employee
WHERE EmpId = 101;
🔍 8. Select Data
sql
SELECT * FROM Employee;
SELECT FirstName, Salary FROM Employee WHERE Department = 'HR';
🔐 9. Add Constraints
Unique Constraint:
sql
ALTER TABLE Employee
ADD CONSTRAINT UQ_Employee_Email UNIQUE (Email);
Default Value:
sql
ALTER TABLE Employee
ADD CONSTRAINT DF_Employee_Salary DEFAULT 50000 FOR Salary;
🧱 10. Add Index
sql
CREATE INDEX IX_Employee_Department ON Employee(Department);


11. Create Stored Procedure
sql
CREATE PROCEDURE InsertEmployee
    @EmpId INT,
    @FirstName VARCHAR(50),
    @LastName VARCHAR(50),
    @DOB DATE,
    @Salary DECIMAL(18,2),
    @Department VARCHAR(50)
AS
BEGIN
    INSERT INTO Employee (EmpId, FirstName, LastName, DOB, Salary, Department)
    VALUES (@EmpId, @FirstName, @LastName, @DOB, @Salary, @Department);
END;
🧪 12. Execute Stored Procedure
sql
EXEC InsertEmployee 
    @EmpId = 102, 
    @FirstName = 'Jane', 
    @LastName = 'Smith', 
    @DOB = '1985-03-22', 
    @Salary = 85000, 
    @Department = 'Finance';
🧾 13. Create Table-Valued Parameter (TVP)
Create Type:
sql
CREATE TYPE EmployeeType AS TABLE (
    EmpId INT,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    DOB DATE,
    Salary DECIMAL(18,2),
    Department VARCHAR(50)
);
Create Procedure:
sql
CREATE PROCEDURE InsertEmployeesBulk
    @Employees EmployeeType READONLY
AS
BEGIN
    INSERT INTO Employee
    SELECT * FROM @Employees;
END;
🔄 14. Drop Table or Type
sql
DROP TABLE Employee;
DROP TYPE EmployeeType;
🧰 15. Other Useful Features
Rename Column:
sql
EXEC sp_rename 'Employee.FirstName', 'GivenName', 'COLUMN';
Rename Table:
sql
EXEC sp_rename 'Employee', 'Staff';
View Table Structure:
sql
EXEC sp_help 'Employee';
Check Constraints:
sql
SELECT * FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE
WHERE TABLE_NAME = 'Employee'

VARCHAR(n) vs NVARCHAR(n) vs VARCHAR(MAX) vs NVARCHAR(MAX)

let's break down the differences between NVARCHAR(MAX) and VARCHAR, and also compare other related types like NVARCHAR(n), VARCHAR(n), and when to use each.

🔍 1. `VARCHAR` vs `NVARCHAR`: Core Difference

Feature	`VARCHAR`	`NVARCHAR`
Character set	Non-Unicode (uses code page)	Unicode (UTF-16)
Bytes per character	1 byte (usually)	2 bytes per character
Language support	Limited to specific locales	Supports all languages (e.g. Hindi, Chinese, Arabic)
Storage size	Smaller (if only English/ASCII)	Larger, but universal
Use case	English or single language data	Multi-language or unknown language data

📏 2. `VARCHAR(n)` vs `NVARCHAR(n)` vs `VARCHAR(MAX)` vs `NVARCHAR(MAX)`

Data Type	Max Length	Unicode	Storage
`VARCHAR(n)`	Up to 8,000 characters	❌ No	Up to 8,000 bytes
`NVARCHAR(n)`	Up to 4,000 characters	✅ Yes	Up to 8,000 bytes (2 bytes/char)
`VARCHAR(MAX)`	Up to 2^31-1 chars (~2 GB)	❌ No	LOB (Large Object) storage
`NVARCHAR(MAX)`	Up to 2^30 chars (~2 GB)	✅ Yes	LOB storage

📌 Notes:

Use MAX only when you expect text > 8,000 characters.
NVARCHAR(MAX) allows for large multilingual documents, e.g. descriptions, logs, or chat histories.
VARCHAR(MAX) is better if you're storing long ASCII or English text only.

🔄 3. Performance Differences

Operation	`VARCHAR(n)` / `NVARCHAR(n)`	`VARCHAR(MAX)` / `NVARCHAR(MAX)`
In-memory operations	Fast	Slower (may spill to disk)
Indexable?	✅ Yes (full indexing)	⚠️ Limited (not fully indexable)
Can be used in temp tables?	✅ Yes	✅ Yes (but slower)
Can be used in computed columns / filters?	✅ Yes	⚠️ Not always

Important: Avoid MAX unless you really need it. It can cause:

Query plan degradation
Table scans
Limited indexing
Extra I/O overhead

🧪 4. Examples


-- VARCHAR vs NVARCHAR (basic)
DECLARE @v1 VARCHAR(50) = 'Hello';       -- ASCII only
DECLARE @v2 NVARCHAR(50) = N'नमस्ते';     -- Unicode required (N prefix)

-- Incorrect: this will not store Unicode properly
DECLARE @wrong VARCHAR(50) = N'你好';  -- Will become ???


-- Use MAX when needed
CREATE TABLE Articles (
    ArticleID INT,
    Title NVARCHAR(255),
    Content NVARCHAR(MAX)  -- Long content, possibly multi-language
);

✅ When to Use Each?

Scenario	Recommended Type
English names, emails	`VARCHAR(255)`
International names, messages	`NVARCHAR(255)`
Very long text (e.g. documents, chat logs)	`NVARCHAR(MAX)`
JSON/XML (long) in English	`VARCHAR(MAX)`
JSON/XML with multilingual text	`NVARCHAR(MAX)`

❗️ Caution: Literal String Prefix `N`

If you're inserting Unicode strings, always use the N prefix:


-- Correct
INSERT INTO Users (Name) VALUES (N'José');   -- NVARCHAR

-- Wrong
INSERT INTO Users (Name) VALUES ('José');    -- VARCHAR: may cause encoding issue

Start With a Tutorial-Based OS

These tutorials walk you through building an OS from scratch:

https://os.phil-opp.com/ — Build a Rust-based OS
https://littleosbook.github.io/ — Simple guide to OS dev
https://wiki.osdev.org/ — Ultimate resource for OS developers

JavaScript + Angular-compatible version of loan amortization calculator that you can integrate into an Angular component or service

JavaScript Version of Loan Amortization

1. Loan Calculator Function (Pure JS/TS)

2. Example Usage in Angular Component

3. Optional Template Snippet

1. Create the Service

✅ 2. Usage in a Component

✅ 3. Template Example (loan.component.html)

complete SQL Server guide with queries from start to end covering how to create tables, add/drop columns, insert/update/delete data, and manage advanced features like constraints, indexes, and stored procedures. This is your go-to reference for working with SQL Server

🧱 1. Create Table

2. Add Columns

🧹 3. Drop Columns

4. Modify Column Data Type

📥 5. Insert Data

🧾 6. Update Data

❌ 7. Delete Data

🔍 8. Select Data

🔐 9. Add Constraints

Unique Constraint:

Default Value:

🧱 10. Add Index

11. Create Stored Procedure

🧪 12. Execute Stored Procedure

🧾 13. Create Table-Valued Parameter (TVP)

Create Type:

Create Procedure:

🔄 14. Drop Table or Type

🧰 15. Other Useful Features

Rename Column:

Rename Table:

View Table Structure:

Check Constraints:

VARCHAR(n) vs NVARCHAR(n) vs VARCHAR(MAX) vs NVARCHAR(MAX)

🔍 1. VARCHAR vs NVARCHAR: Core Difference

📏 2. VARCHAR(n) vs NVARCHAR(n) vs VARCHAR(MAX) vs NVARCHAR(MAX)

📌 Notes:

🔄 3. Performance Differences

🧪 4. Examples

✅ When to Use Each?

❗️ Caution: Literal String Prefix N

Start With a Tutorial-Based OS

JavaScript + Angular-compatible version of loan amortization calculator that you can integrate into an Angular component or service

Best for you

✅ 3. Template Example (`loan.component.html`)

🔍 1. `VARCHAR` vs `NVARCHAR`: Core Difference

📏 2. `VARCHAR(n)` vs `NVARCHAR(n)` vs `VARCHAR(MAX)` vs `NVARCHAR(MAX)`

❗️ Caution: Literal String Prefix `N`