DEV Community: Kaweesha Marasinghe

Turbocharging TypeScript: What Happens When You Rebuild It in Go

Kaweesha Marasinghe — Sun, 03 Aug 2025 05:52:40 +0000

Why Microsoft Is Rewriting the TypeScript Compiler in Go

A few months ago, Microsoft announced they’re rewriting the TypeScript compiler — not the language — from JavaScript (running on Node.js) to Go.

The goal?

Faster compiler performance, not faster TypeScript apps.

Think of It Like This:

If you're building cars and upgrade your car manufacturing machines, the cars themselves don’t suddenly drive faster. But now, you can build those cars much faster.

Same thing here:

The TypeScript compiler is the manufacturing machine.
Microsoft is rebuilding that machine in Go to make it faster and more efficient.

The language (TypeScript) itself stays the same.

What’s changing is the engine behind it.

Node.js Architecture Breakdown

For years, the TypeScript compiler has run on Node.js, which uses Google’s V8 engine (same as Chrome).

Here’s what powers Node.js:

V8: Written in C/C++, compiles JavaScript to machine code using JIT (Just-In-Time) compilation.
libuv: C library that handles async I/O like file access and network calls.
Many of Node’s performance advantages come from these native under-the-hood parts.

But there’s a catch:

Node.js is great for I/O and memory-heavy work — but not for CPU-heavy tasks.

Examples:

I/O-bound (Node is good at):

Database queries
Network/API calls
File system operations

Memory-bound:

Parsing JSON
Data transformations
Routing HTTP requests

But when you throw CPU-intensive jobs at it (like compiling a codebase), Node slows down.

Why Node.js Struggles with Compilers

Node.js is single-threaded by default.

If one heavy task (like compiling) runs, it blocks the event loop, so:

No new requests get handled
Everything waits until that one job finishes

That’s a big problem for something like a compiler.

So... Is a Compiler CPU-Bound?

Yes — compilers are classic CPU-bound programs.

They don’t just read files or wait on databases. They do serious processing:

Type checking
Code analysis
Transformations
Output generation

These tasks hit the CPU hard — not I/O, not memory.

As TypeScript has added more features (generics, decorators, etc.), the compiler has gotten more complex and CPU-hungry.

Why Go Is a Better Fit

Go’s Superpower: Goroutines

Go has a built-in concurrency model — goroutines — which are:

Lightweight threads
Can run thousands at once
Managed by Go’s own scheduler, not the OS

That means Go can:

Type-check multiple files in parallel
Transform code without freezing
Generate output concurrently
All without blocking anything else

Compare that to Node.js, which relies on workarounds (like worker threads) to get any kind of parallelism.

Another advantage: Go produces native executables — .exe for Windows, ELF for Linux, etc.

No need for:

Node.js runtime
JS engine like V8
External dependencies

That makes it perfect for:

CLI tools
Build systems
Fast startup and distribution

Compare this to Node.js:

Needs V8 at runtime
Slower cold starts
More dependencies to carry

Microsoft’s Smart Move

Anders Hejlsberg said they evaluated multiple languages, and Go was the easiest to port the code base into. The TypeScript team has apparently created a tool that generates Go code, resulting in a port that's nearly line-for-line equivalent in many places. That might lead you to think the code is "doing the same thing," but that's a misconception.

This isn’t just a performance tweak — it’s a strategic shift in how dev tools are built.

What About Browser Support?

The current TypeScript compiler runs in browser tools like the TS Playground. But Go doesn’t naturally run in browsers.

So how could this work?

Possible Approaches:

1. WebAssembly (WASM)

Go can be compiled to WASM
Works in browsers
Has limitations (e.g., no full multithreading)

Might be used for basic tasks (like playgrounds or small apps).

2. Cloud Compilation

Browser sends code to a remote server running the Go compiler
Server returns compiled output/errors
Very scalable, browser stays lightweight

3. Dual Compiler Strategy

Keep the JS-based compiler for browsers
Use the Go compiler for CLI/build tools/IDEs
Harder to maintain both, but possible

4. Lite Browser Version

Stripped-down version for type-checking/syntax validation
Could use WASM or JS under the hood
Good enough for teaching and small projects

Microsoft hasn’t officially confirmed their plan yet.

These are educated guesses based on blog posts and engineering trends.

Final Thoughts
Microsoft’s decision to rewrite the TypeScript compiler in Go isn’t just about raw speed — it’s about building a modern, scalable toolchain that matches the complexity of today’s codebases. Go’s native concurrency, efficient memory usage, and ability to produce fast binaries make it a perfect fit for powering large-scale developer tools.

While this move introduces questions around browser support, the likely hybrid model (Go for CLI, JS/WASM for browser) shows that Microsoft is thinking long-term.

In the end, the language we write (TypeScript) stays the same — but the tools we use to build and scale with it are evolving. And that evolution, powered by Go, could shape the future of how fast, reliable, and portable our dev workflows become.

Object-Oriented Concepts: The Foundation of Modern Programming - Part 01

Kaweesha Marasinghe — Sat, 18 Jan 2025 08:10:11 +0000

What Came Before OOP

Procedural Programming (1950s-70s)

Procedural programming was a paradigm that followed a step-by-step approach to solving problems by breaking them into smaller tasks or procedures.

In its early stages, C was a widely used procedural programming language. Here’s an example of a simple procedural program in C:

#include <stdio.h>

void calculateTotal() {
    int price1 = 10, price2 = 20, total;
    total = price1 + price2;
    printf("Total: %d\n", total);
}

int main() {
    calculateTotal();
    return 0;
}

While procedural programming worked well for smaller, straightforward programs, it started to face challenges as software became more complex. This complexity brought several issues:

Code Duplication: The same logic was often repeated in different parts of the program.
Maintenance Problems: A single change required modifications in multiple places, increasing the risk of errors.
Scalability Issues: Procedural programming struggled to adapt to the growing demands of larger, more complex software.
Poor Representation of Real-World Scenarios: Data and operations were kept separate, making it difficult to model real-world entities like a "Bank Account" or "Car."

The Shift to Object-Oriented Programming (OOP)

As software complexity grew, procedural programming began to show its limitations. This led to the evolution of a new paradigm—Object-Oriented Programming (OOP). OOP revolutionized the way we design and build software by modeling real-world entities and combining data and behavior into a single unit called an object.

Key Concepts of OOP

1. Encapsulation 🛡

Encapsulation binds data (attributes) and behaviors (functions) that operate on the data into a single entity, typically a class. This means we can group related data and methods together into one unit and control how the data is accessed and modified. This promotes data security and modularity.

Encapsulation is implemented with the support of access specifiers:

Private variables: These protect sensitive data by restricting outside access to variables.
Public methods: These provide functionality to modify or access the private data from the outside.

Why Encapsulation is Important:

Data Protection: By using private access specifiers, some attributes (e.g., accBalance) are restricted from direct modification.
Modularity: Changes made internally won't affect external code that interacts with the object.

Example:

A great example of encapsulation is a TV remote.

The remote has several buttons that perform actions. Each button is coded to execute a related function when pressed, but you cannot change the underlying code that defines what each button does. The remote hides the implementation details, providing you with public methods (the buttons) while keeping the internal functions (private attributes) hidden.

2. Abstraction 🔍

As the complexity of a system grows, abstraction plays a vital role in managing that complexity. Abstraction is the concept that hides the complex details and only exposes the essential features.

The goal of abstraction is to simplify the interface and reduce the complexity for the user or objects interacting with it.

Example:

When you drive a car, you use the steering wheel, accelerator, brakes, and gear shifts, which are essential for driving.

But to drive, you don’t need to know how the gears are shifted, how the brake system works, or how the wheels rotate when you turn the steering wheel. These details are hidden (abstracted) from you.

You only interact with the simplified interface: the brake, accelerator, and steering wheel.

How to Use Abstraction in OOP

Abstract Classes:

Use abstract classes when you want to share common behavior but allow subclasses to provide specific implementations.

Example: A Shape class might have a method calculateArea(). You can abstract the calculation in the base class and allow subclasses like Circle, Rectangle, etc., to implement their specific area calculations.

Interfaces:

Use interfaces when you want to ensure a class implements certain behaviors but don’t care about the implementation details.

Example: An IPlayable interface that requires play() and pause() methods. Any class that implements this interface, like AudioPlayer or VideoPlayer, must provide implementations for play() and pause().

Code Example

// Abstract class - Shape (provides a blueprint for all shapes)
abstract class Shape {
    // Abstract method (does not have implementation)
    public abstract double calculateArea(); 

    // Concrete method (implemented in the abstract class)
    public void displayShape() {
        System.out.println("This is a shape.");
    }
}

// Concrete class - Circle (specific implementation of calculateArea)
class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;  // Area of circle
    }
}

// Concrete class - Rectangle (specific implementation of calculateArea)
class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;  // Area of rectangle
    }
}

public class Main {
    public static void main(String[] args) {
        // Create objects of Circle and Rectangle
        Shape myCircle = new Circle(5.0);  // radius = 5
        Shape myRectangle = new Rectangle(4.0, 6.0);  // length = 4, width = 6

        // Display the shape and calculate areas
        myCircle.displayShape();
        System.out.println("Circle Area: " + myCircle.calculateArea());

        myRectangle.displayShape();
        System.out.println("Rectangle Area: " + myRectangle.calculateArea());
    }
}

🌟 In Conclusion 🌟

As we've explored, the shift from procedural programming to Object-Oriented Programming (OOP) introduced us to powerful concepts such as Encapsulation and Abstraction that make software more manageable, scalable, and modular. 🌍💻

By focusing on objects that represent real-world entities, OOP allows developers to write cleaner and more maintainable code. 🎯

Embrace OOP, and start designing software that mirrors the complexity of the real world in an elegant and efficient manner! ✨

Getting Started with Hibernate: An Introduction to ORM and JPA Annotations

Kaweesha Marasinghe — Sun, 12 Jan 2025 03:49:07 +0000

In my previous blog post, we explored how databases work and delved into the differences between relational, object-oriented, and object-relational databases. If you haven’t read it yet, feel free to check it out here.

Building on that foundation, this blog will dive into Object-Relational Mapping (ORM)—a concept that bridges the gap between object-oriented programming and relational databases. Specifically, we’ll focus on how ORM frameworks like Hibernate simplify the process of mapping Java objects to database tables. This not only makes database operations more intuitive but also helps developers create and manage database structures seamlessly from their Java code. 🚀

What is ORM?

Object-Relational Mapping (ORM) is a technique used to map Java objects to database tables, making it easier to handle databases without writing raw SQL queries.

Example:

Without ORM, performing CRUD (Create, Read, Update, Delete) operations requires writing raw SQL queries like SELECT, INSERT, UPDATE, and DELETE to interact with the database.

With ORM, you can retrieve data and map it to Java objects effortlessly, eliminating the need for extensive SQL code.

Hibernate: The Go-To ORM Tool

Hibernate is an implementation of JPA (Java Persistence API). JPA is a standard specification for managing relational data, while Hibernate adheres to this specification and performs ORM operations.

Hibernate simplifies database interaction by allowing developers to write database-independent code. This means you can switch your data source with minimal changes to your application code.

Why Use Hibernate?

With Hibernate, developers can:

Avoid writing raw SQL queries.
Work with Java objects instead of relational data structures.
Easily switch between different databases with minimal code adjustments.

JPA Annotations in Hibernate

To handle ORM operations, Hibernate relies on JPA annotations. Below, we’ll cover 8 of the most commonly used JPA annotations that make database operations seamless.

1. `@Entity` 🏛️

This annotation marks a Java class as a JPA entity, which maps to a table in the database. For example, if a class called User is annotated with @Entity, Hibernate will treat it as a table in the database, with its attributes mapped to table columns.

Example:

@Entity
public class User {
    @Id
    private Long id;
    private String name;
    private String email;
}

The User class will be mapped to a table named User in the database.
The class attributes (id, name, email) will become columns in the table.

2. `@Table` 🗄️

The @Table annotation allows customization of the table name and other table-specific attributes.

By default, when a class is annotated with @Entity, the database table will have the same name as the entity class. However, if you want a different name, you can customize it using @Table.

Example:

@Entity
@Table(name = "users", schema = "public")
public class User {
    @Id
    private Long id;
    private String name;
    private String email;
}

The User class is mapped to a table named users in the public schema.

3. `@Id` 🆔

Every entity class must have a primary key to uniquely identify records in the corresponding table. The @id annotation is used to specify which attribute serves as the primary key.

Example:

@Entity
public class User {
    @Id
    private Long id;
    private String name;
}

The id field is now the primary key of the User entity and corresponds to the primary key column in the database table.

4. `@GeneratedValue` 🔢

The @GeneratedValue annotation specifies how the primary key value is generated. Hibernate supports four key strategies:

IDENTITY: The primary key is auto-incremented, similar to SQL database behavior.
SEQUENCE: Uses a database sequence to generate unique values.
TABLE: Uses a separate database table to generate primary key values. This method is slower due to additional database reads.
AUTO: JPA automatically selects the generation strategy based on the database dialect.

Example:

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

In this example, the id value will be auto-incremented by the database.

5.`@Column` 📋

The @column annotation is used to define column-specific constraints and customize column names in the database.

Example:

@Column(name = "full_name", nullable = false, unique = true)
private String name;

Maps the name field to a column named full_name.
The column cannot have null values (nullable = false) and must contain unique entries (unique = true).

6. `@OneToMany and @ManyToOne` 🔗

These annotations define relationships between entities:

@OneToMany: A parent entity is related to multiple child entities.
@ManyToOne: A child entity is related to a single parent entity.

Example: Parent-Child Relationship

Let’s say a User can have multiple Order records.

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
    private List<Order> orders;
}

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String description;

    @ManyToOne
    @JoinColumn(name = "user_id") // Foreign key in the "orders" table
    private User user;
}

@OneToMany in User indicates a list of Order entities.
@ManyToOne in Order links each order to a single user.
@JoinColumn defines the foreign key column (user_id) in the orders table.

Wrapping It All Up 🎁

Hibernate and JPA annotations make database interactions seamless, bridging the gap between Java objects and relational databases. They eliminate the need to write raw SQL queries and ensure your application remains database-independent.

In the next blog post, we’ll explore advanced Hibernate topics like caching, transactions, and best practices for optimizing performance.

Stay tuned, and happy coding! ✨

From SQL to Object-Oriented Databases: Navigating the Evolution of Database Models

Kaweesha Marasinghe — Thu, 09 Jan 2025 12:42:22 +0000

When we talk about databases, SQL often comes to mind. Most people are familiar with SQL and relational databases, which use tables to organize and store data. But have you ever heard of Object-Oriented Databases? 🤔

At first glance, the term may seem unfamiliar. We all know about Object-Oriented Programming (OOP), but a database based on OOP concepts? Sounds new, right? 🤷‍♂️

Well, you're partially right! Object-oriented databases do indeed borrow principles from OOP, enhancing the capabilities of traditional databases and significantly boosting their performance. But how? Let’s dive in! 🚀

What are Relational Databases? 📊

Relational databases store data in tables, similar to how you would organize information in an Excel spreadsheet. Each column holds a specific type of data (like numbers, text, or dates), and each row represents a unique record.

Limitations of Relational Databases ⚠️

However, as Benjamin says in "Who Am I" (2016): "No system is perfect." Relational databases have their own set of issues:

Struggle with Multimedia Data:
Relational databases find it difficult to handle large, unstructured data like images and videos, often storing them as files and referencing them with keys, which can slow down performance.
Set-Value Attributes:
When you need to store multiple values in one field (e.g., a list of skills for an employee), relational databases struggle. This requires creating extra tables or complex structures to manage such data.
Hierarchical Data:
Data with parent-child relationships (like organizational charts or family trees) doesn't fit neatly into tables, making it hard to represent complex structures efficiently.

To tackle these limitations, object-oriented databases emerged as a new breed. 🧬

What are Object-Oriented Databases? 🛠️

An Object-Oriented Database (OODB) is a database system that stores data in the form of objects, similar to how objects are handled in Object-Oriented Programming (OOP) languages like Java or C++. This makes OODBs ideal for applications that work with complex data and relationships.

A Relational Database (RDBMS) stores data in tables with rows and columns, and managing complex or hierarchical relationships often requires creating multiple tables, foreign keys, and applying normalization. This can make the system more complex, especially when dealing with data that doesn’t naturally fit into tables, such as nested objects or relationships like many-to-many.

For example, imagine you have a Student table with attributes like name, age, multiple phone numbers, and a list of certificates the student is enrolled in. In a relational database, you would need to create multiple columns for each attribute (including handling lists like phone numbers and certificates by normalizing the data into separate tables). You would also need to set up complex relationships to link these tables.

However, with an Object-Oriented Database, you can store the entire Student object — including its name, age, phone numbers, and certificates — as a single object within one column. This simplifies the process significantly, as you no longer need to manage multiple tables and relationships for the data. Instead, the complex data is encapsulated into a single object that can be stored and retrieved easily. 🧩

However, object-oriented databases were also replaced by another breed:

Object-Relational Databases ⚡

Why Object-Relational Databases Replaced Object-Oriented Databases (OODB)

Limited Adoption of OOP:
OODB worked well with object-oriented languages but didn’t work well with traditional procedural languages.
SQL Dependency:
Many organizations still rely on SQL because moving from SQL to OODBs was challenging.
Performance Issues:
While OODBs handled complex objects well, they sometimes struggled with high-performance needs in applications requiring simple, structured data.
Integration Challenges:
Many organizations already had relational databases in place. Completely replacing these systems with OODBs was impractical and expensive.

These issues led to the emergence of a new database technology: Object-Relational Databases. 🎯

What are Object-Relational Databases? 🌀

Object-relational databases were developed as a mixture of relational and object-oriented databases. They combined the best features of relational databases and OODBs.

Features of Object-Relational Databases

Maintain the Standard Relational Model:
They allow the creation of custom data types, nested data, and user-defined functions while still being compatible with SQL.
SQL Compatibility:
This extension of SQL provides the ability to query both complex data as well as traditional data with a well-established standard.
Gradual Adoption:
Organizations could keep their relational databases while gradually introducing object-oriented features.

Examples of Database Models 📚

1. Relational Model (RDBMS)

Scenario: Storing information about a Student and their Courses.

Example: Relational Model

Storing information about Students and Courses.

`Students` Table

StudentID	Name	Age
1	Alice	21
2	Bob	22

`Courses` Table

CourseID	CourseName
101	Mathematics
102	Computer Science

`StudentCourses` (Join Table)

StudentID	CourseID
1	101
1	102
2	101

Characteristics:

Data is stored in flat, structured tables.
Relationships are managed using foreign keys and joins.
Querying is done using SQL.

2. Object-Oriented Model (OODB)

Scenario: Representing a Student as an object with nested attributes.

Object Representation:

{
  "StudentID": 1,
  "Name": "Alice",
  "Age": 21,
  "Courses": [
    {"CourseID": 101, "CourseName": "Mathematics"},
    {"CourseID": 102, "CourseName": "Computer Science"}
  ]
}

Characteristics:

Data is stored as objects, similar to programming languages like Java or Python.
No need for separate tables or joins.
Methods (e.g., getCourseList() or calculateAge()) can be attached to objects.
Querying is done using object-oriented APIs instead of SQL.

3. Object-Relational Model (ORD)

Scenario: Combining relational structure with object-oriented features.

PostgreSQL Example:

Define a custom type for Courses:

CREATE TYPE Course AS (
    CourseID INT,
    CourseName TEXT
);

Create a Students table with a column for nested courses:

CREATE TABLE Students (
    StudentID SERIAL PRIMARY KEY,
    Name TEXT,
    Age INT,
    Courses Course[]
);

Insert data:

INSERT INTO Students (Name, Age, Courses)
VALUES (
    'Alice', 
    21, 
    ARRAY[ROW(101, 'Mathematics')::Course, ROW(102, 'Computer Science')::Course]
);

Query nested data:

SELECT Name, Age, Courses FROM Students WHERE Name = 'Alice';

Characteristics:

Combines relational structure with object-oriented features like nested types and arrays.
Uses extended SQL to handle complex data types.
Provides a middle ground between RDBMS and OODB.

Summary Table

Model	Structure	Example Data
Relational Model	Flat tables with relationships	Students, Courses, Join tables
Object-Oriented	Hierarchical, nested objects	JSON-like objects or OOP classes
Object-Relational	Tables with nested data and objects	Arrays, custom types in tables

🎉 Hope this helps clarify the different database models! Let me know if you have questions! 😊

Understanding the Spring Framework: A Developer’s Journey to Clean Code 🚀

Kaweesha Marasinghe — Mon, 06 Jan 2025 12:22:32 +0000

Introduction: The Early Java Era

In the early era of programming, writing Java code was a bit frustrating. Developers had to set up long configurations, deal with verbose XML files, and manually manage dependencies that were rapidly updated. This era made it harder for developers to thrive and write efficient code.

In 2003, Spring Framework revolutionized the Java ecosystem by introducing Dependency Injection (DI) and Inversion of Control (IoC). These features significantly reduced developers' headaches by eliminating tightly coupled code and making it easier to write clean, modular code. 🙌

What is Inversion of Control (IoC)? 🤔

IoC is a design principle where the control of object creation and dependency management is transferred to a container (like the Spring IoC container). Instead of objects managing their own dependencies, the container does this work for you! 🎉

Normal (Without IoC) Behavior

Without IoC, developers are responsible for creating and managing their object dependencies.

For example, let’s consider a Car class that depends on an Engine class. In this scenario, the Car class manages the Engine object by itself:

public class Car {
    private Engine engine = new Engine();  // Car directly creates an Engine

    public void start() {
        engine.run();
    }
}

In this case:

The Car class directly creates the Engine object.
The Car class is responsible for both creating and managing the Engine object, which creates a tight coupling between the two.
If we want to change the Engine class (for example, to use a HybridEngine), we’d need to modify the Car class. This violates the Open/Closed Principle: classes should be open for extension but closed for modification. 🚧

With IoC in Spring (Dependency Injection) 🛠️

In IoC and Dependency Injection (DI), Spring takes care of creating and injecting dependencies into your classes.

Simply put, the Spring IoC container creates the Engine object and injects it into the Car object when required. This way, you don’t have to manually manage object creation or dependencies. Spring handles it for you. 🧑‍💻

public class Car {
    private Engine engine;  // Engine is injected by Spring, not created by Car

    // Constructor-based injection
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.run();
    }
}

How Does Spring Know Which Objects to Inject? 🧐

Spring uses Spring Beans to manage the lifecycle and dependencies of objects. In Spring, a bean is an object that the Spring IoC container manages. The container knows which beans to create and inject based on your configuration. 🌱

Spring Beans and Bean Lifecycle 🔄

In Spring, a bean is any object that is managed by the Spring IoC container. The container is responsible for:

Instantiation: Creating the bean.
Dependency Injection: Injecting the required dependencies.
Initialization: Calling any initialization methods (e.g., @PostConstruct).
Destruction: Calling cleanup methods (e.g., @PreDestroy).

How to Define a Spring Bean? 🏷️

You can define beans using annotations:

@Component: Marks a class as a Spring-managed bean. Spring automatically detects and instantiates this class during component scanning.
@Autowired: Tells Spring to inject the required dependency (either via constructor, field, or setter).
@Configuration: Used to define bean definitions using Java configuration (using @Bean).

Example with annotations:

@Component
public class Car {
    private Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.run();
    }
}

@Component
public class Engine {
    public void run() {
        System.out.println("Engine is running...");
    }
}

Advantages of IoC (and DI) 🏆

By using IoC and DI, Spring offers several advantages:

Loose Coupling: The Car class is no longer tightly coupled with the Engine. It only depends on the interface or type, not the specific implementation. This makes it easy to swap the Engine type, such as using an ElectricEngine instead of a GasolineEngine. 🔄
Easier Testing: Since dependencies are injected, you can easily substitute mock objects or different implementations when writing unit tests for the Car class. 🧪
Flexibility: You can change the dependencies externally (e.g., through Spring configuration) without modifying the core business logic of the classes. 🔧

Spring Configuration Methods

There are three primary ways to configure Spring beans and the IoC container:

1. XML Configuration (Traditional) 📜

In the traditional approach, beans are defined in an XML configuration file. This method is becoming less common but is still used in legacy systems.

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="car" class="com.example.Car">
        <constructor-arg ref="engine"/>
    </bean>

    <bean id="engine" class="com.example.Engine"/>
</beans>

2. Annotation-based Configuration (Modern) 🏷️

The modern approach uses annotations like @Component, @Autowired, and @Configuration to define and inject beans.

@Component
public class Car {
    private Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.run();
    }
}

To enable annotation-based configuration, use @ComponentScan in a configuration class:

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // Spring scans the specified package for @Component annotated classes
}

3. Java-based Configuration (Best for Type Safety) 🖥️

Java-based configuration uses @Configuration and @Bean annotations, which is more type-safe and easier to maintain.

@Configuration
public class AppConfig {

    @Bean
    public Car car() {
        return new Car(engine());
    }

    @Bean
    public Engine engine() {
        return new Engine();
    }
}

Conclusion 🏁

In this blog, we’ve explored:

IoC (Inversion of Control): The core design principle where Spring takes control of object creation and dependency management.
DI (Dependency Injection): A technique that helps Spring inject dependencies into your beans, allowing for clean and flexible code.
Spring Beans: Objects that are managed by Spring, and how their lifecycle is handled by the IoC container.
Spring Configuration: Different ways to configure Spring beans, from XML to annotations to Java-based configurations.

Spring's powerful IoC and DI capabilities help you write cleaner, more modular, and easily testable code. 🌟

Building Secure Authentication Microservices with Spring Boot: Part 1 - Getting Started

Kaweesha Marasinghe — Tue, 24 Dec 2024 03:38:53 +0000

🌟 In the World of Programming: Spring Boot & Authentication

When you hear the word Spring Boot, what comes to mind? 💭 Chances are, it’s authentication. But why? 🤔 What makes Spring Boot so closely tied to authentication? Is there some secret connection? 🕵️‍♂️ Let’s uncover the truth!

🌱 What is Spring Boot?

Spring Boot is a Java framework built on top of the Spring Framework, designed to:

Help developers quickly build production-ready 🚀, standalone Java applications.
It’s a go-to framework for enterprise-level applications 🏢.

✨ Why is Spring Boot So Popular?

Quick Setup ⚡
- Eliminates complex configurations by using built-in templates.
Opinionated Defaults 🎯
- Provides pre-configured settings for common setups.
- You can start quickly but still customize and enhance as needed.
Embedded Servers 🔧
- No need for external servers like Tomcat!
- You can run your application directly without extra setup.
Microservices Support 🛠️
- Perfect for creating small, scalable, and independent services.
- Each microservice can be deployed and scaled separately.

🛡️ Spring Boot’s Authentication Powers

So, this is Spring Boot. But where do all these authentication superpowers come from? 🤔

That’s where Spring Security comes into play! 💥

With this Infinity Stone 💎, even your simplest application gets the power to ensure that only authorized people make it through the door! 🚪👊

Spring Security

(Or, may I ask, what does this Infinity Stone do?)

Think of Spring Security as the ultimate sidekick to your Spring Boot app. 🦸‍♂️

It gives your application the power to:

Protect against unauthorized access. 🚫
Shield your app from malicious attacks 🔒 like CSRF, XSS, etc.

🛡️ Features of Spring Security

Authentication 🔑
- Verifies the user’s identity.
- Checks if the username/password or token (like JWT) is valid.
Authorization 🛂
- Determines what actions or resources a user is allowed to access.
Protection Against Common Attacks 🛡️
- Mitigates threats like Cross-Site Request Forgery (CSRF) and Cross-Site Scripting (XSS).

🌐 Why Spring Boot for Authentication?

Sure, you can use other languages like Node.js or Go for authentication. 🐹 🚀

But Spring Boot stands out because:

Integration with Spring Ecosystem:
- Out-of-the-box support for OAuth2, JWT, and other modern protocols.
Enterprise-grade Security:
- Ready-made integrations with LDAP, SSO, and Active Directory.
Rich Ecosystem:
- Vast documentation 📚 and an active community.
Microservices-ready:
- Ideal for secure, stateless microservices architectures.

Every Superhero Needs a Sidekick 🦸‍♂️🛡️

In the world of authentication, JWT (JSON Web Token) is the sidekick that never misses its mark. 🎯

📝 What is JWT?

JWT is a compact, URL-safe token used to:

Authenticate users. 🔑
Authorize their actions in web applications. 🌐

🧩 Key Features of JWT

Compact 📦
- Small in size, making it efficient for web transmission.
Self-Contained 📜
- All necessary user/session information is inside the token.
- No need for server-side sessions!
Secure 🔒
- Digitally signed to ensure integrity and authenticity.

⚙️ Structure of a JWT

A JWT consists of three parts, separated by dots (.):

Header:
- Metadata like token type and signing algorithm.

Example:

   {
     "alg": "HS256",
     "typ": "JWT"
   }

Payload:
- Contains user data or claims.

Example:

   {
     "sub": "1234567890",
     "name": "John Doe",
     "admin": true
   }

Signature:
- Ensures the token hasn’t been tampered with.

Example:

   HMACSHA256(
     base64UrlEncode(header) + "." + base64UrlEncode(payload), 
     secret
   )

🛠️ How JWT Works

User Logs In 🔐
- Provides credentials (e.g., username/password).
- Server generates a JWT and sends it to the client.
Client Stores JWT 💾
- Stored in localStorage or cookies.
Client Sends JWT with Requests 📩
- Token is sent in the Authorization header:
```
 Authorization: Bearer <JWT>
```
Server Verifies JWT ✅
- Checks the token’s validity and processes the request.

🤔 Why Use JWT?

Stateless: No server-side sessions required.
Scalable: Perfect for distributed systems.
Cross-Domain: Great for APIs.

What’s Next?

So, this was the basic breakdown of the key players in an authentication microservice:

Spring Boot 🌱
Spring Security 🛡️
JWT 🎯

In the next blog, we’ll start coding from scratch to build a robust authentication microservice using these powerful tools. 🚀

Let’s get coding! 💻✨

DEV Community: Kaweesha Marasinghe

Turbocharging TypeScript: What Happens When You Rebuild It in Go

Why Microsoft Is Rewriting the TypeScript Compiler in Go

Think of It Like This:

Node.js Architecture Breakdown

Node.js is great for I/O and memory-heavy work — but not for CPU-heavy tasks.

Examples:

Why Node.js Struggles with Compilers

So... Is a Compiler CPU-Bound?

Why Go Is a Better Fit

Go’s Superpower: Goroutines

Microsoft’s Smart Move

What About Browser Support?

Possible Approaches:

1. WebAssembly (WASM)

2. Cloud Compilation

3. Dual Compiler Strategy

4. Lite Browser Version

Object-Oriented Concepts: The Foundation of Modern Programming - Part 01

What Came Before OOP

Procedural Programming (1950s-70s)

The Shift to Object-Oriented Programming (OOP)

Key Concepts of OOP

1. Encapsulation 🛡

Why Encapsulation is Important:

Example:

2. Abstraction 🔍

Example:

How to Use Abstraction in OOP

Abstract Classes:

Interfaces:

Code Example

🌟 In Conclusion 🌟

Getting Started with Hibernate: An Introduction to ORM and JPA Annotations

What is ORM?

Example:

Hibernate: The Go-To ORM Tool

Why Use Hibernate?

JPA Annotations in Hibernate

1. @Entity 🏛️

2. @Table 🗄️

3. @Id 🆔

4. @GeneratedValue 🔢

5.@Column 📋

6. @OneToMany and @ManyToOne 🔗

Wrapping It All Up 🎁

From SQL to Object-Oriented Databases: Navigating the Evolution of Database Models

What are Relational Databases? 📊

Limitations of Relational Databases ⚠️

What are Object-Oriented Databases? 🛠️

Object-Relational Databases ⚡

Why Object-Relational Databases Replaced Object-Oriented Databases (OODB)

What are Object-Relational Databases? 🌀

Features of Object-Relational Databases

Examples of Database Models 📚

1. Relational Model (RDBMS)

Example: Relational Model

Students Table

Courses Table

StudentCourses (Join Table)

Characteristics:

2. Object-Oriented Model (OODB)

Object Representation:

Characteristics:

3. Object-Relational Model (ORD)

PostgreSQL Example:

Characteristics:

Summary Table

Understanding the Spring Framework: A Developer’s Journey to Clean Code 🚀

Introduction: The Early Java Era

What is Inversion of Control (IoC)? 🤔

Normal (Without IoC) Behavior

With IoC in Spring (Dependency Injection) 🛠️

How Does Spring Know Which Objects to Inject? 🧐

Spring Beans and Bean Lifecycle 🔄

How to Define a Spring Bean? 🏷️

Advantages of IoC (and DI) 🏆

Spring Configuration Methods

1. XML Configuration (Traditional) 📜

2. Annotation-based Configuration (Modern) 🏷️

1. `@Entity` 🏛️

2. `@Table` 🗄️

3. `@Id` 🆔

4. `@GeneratedValue` 🔢

5.`@Column` 📋

6. `@OneToMany and @ManyToOne` 🔗

`Students` Table

`Courses` Table

`StudentCourses` (Join Table)