DEV Community: rachel

Event Driven Design & Message Driven Design

rachel — Mon, 19 Jan 2026 03:11:35 +0000

Event Driven Design (EDD)

Before we dive into EDD, let's define an event. An event is immutable and represents a state change in the past.

The core idea of EDD is that systems react to events, facts that something has already happened. In EDD, producers don’t know who consumes the events, hence achieving high decoupling.

Typical flow

A service performs an action
It publishes an event
Zero or more consumers react independently

Example: Order Service successfully creates an order, and emits an event.

The consumers in this scenario could be:

Inventory Service reduces stock
Email Service sends confirmation
Analytics Service tracks metrics

Common Misconception

A common pitfall of developers is expecting replies from events. Events are one-way notifications, not conversations. When you publish an event, you are saying "this happened", not "please respond".

Message Driven Design (MDD)

Unlike EDD that reacts to things that have already happened, MDD instructs services to perform actions. These systems send messages to request work from another system.

Messages are intent-based (eg. ProcessPayment, SendEmail, GenerateInvoice) and sender often expects processing to occur.

Typical flow

Sender sends a message
Receiver processes it
Optional response or acknowledgment

Example: Order Service sends a ProcessPayment message to Payment Service

When to use EDD or MDD?

A useful mental model for choosing between the two is that one is reactive and the other is instructive: ‘an order was placed’ versus ‘place an order’. Most modern architectures combine both, where commands initiate work and events announce results.

Example

Checkout Service
   ├─ sends → ProcessPayment (message)
   └─ publishes → PaymentCompleted (event)

SOLID Principles Explained (with examples in Java)

rachel — Thu, 02 May 2024 15:41:06 +0000

The SOLID principles, conceptualized by Robert C. Martin (aka Uncle Bob), is a fundamental design principles that aim to create well-structured and maintainable code. This article will walk you through the 5 principles with examples.

1. Single Responsibility Principle (SRP)

"A class should have only one reason to change."
Each class, method, or function should serve a single, well-defined purpose, with all elements within it supporting that purpose.
If a change needs to be made, it should only affect that single responsibility, and not other unrelated parts of the codebase.

// Violates SRP
public class BankAccount {
    private double balance;

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds");
        }
    }

    public void printBalance() {
        System.out.println("Current balance: " + balance);
    }
}

The code above violates SRP because say if the requirement changed to display the balance in a different format, then the BankAccount class would need to be updated, hence violating SRP. To resolve this, we can separate them into 2 classes, ensuring that each class has a single responsibility.

// Follows SRP
public class BankAccount {
    private double balance;

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            throw new IllegalArgumentException("Insufficient funds");
        }
    }

    public double getBalance() {
        return balance;
    }
}

public class BalanceDisplayer {
    public void printBalance(BankAccount account) {
        System.out.println("Current balance: " + account.getBalance());
    }
}

2. Open closed Principle (OSP)

"Software components should be open for extension but closed for modification."
New functionality can be added without changing existing code.

Using the same example above, let's say we want to display the balance in a few formats. To modify the BalanceDisplayer class without violating OCP, we need to design the code in such a way that everyone can reuse the feature by just extending it.

// Interface for balance display
public interface BalanceDisplay {
    void displayBalance(BankAccount account);
}

// Implementation for displaying balance in a simple format
public class SimpleBalanceDisplay implements BalanceDisplay {
    @Override
    public void displayBalance(BankAccount account) {
        System.out.println("Current balance: " + account.getBalance());
    }
}

// Implementation for displaying balance in a fancy format
public class FancyBalanceDisplay implements BalanceDisplay {
    @Override
    public void displayBalance(BankAccount account) {
        System.out.println("~~~ Fancy Balance: $" + account.getBalance() + " ~~~");
    }

3. Liskov substitution Principle (LSP)

"Derived or child classes must be substitutable for their base or parent classes."
If B is a subclass of A, B should be able to replace A without affecting the correctness of the program.

// Subclass SavingsAccount
public class SavingsAccount extends BankAccount {
    public SavingsAccount(double balance) {
        super(balance);
    }

    // Additional functionality specific to SavingsAccount
    public void calculateInterest() {
        // Calculate interest for savings account
    }
}

public class GoldAccount extends BankAccount {
    private double bonusPoints;

    public GoldAccount(double balance, double bonusPoints) {
        super(balance);
        this.bonusPoints = bonusPoints;
    }

    @Override
    public void deposit(double amount) {
        balance += amount + (bonusPoints * 0.1); // Adds bonus points to the deposit
    }
}

SavingsAccount adheres to LSP as it extends the functionality by adding specific methods like calculateInterest, which do not alter the core behavior of depositing and withdrawing funds.
GoldAccount class violates LSP by changing the behavior of the deposit method from the base BankAccount class.

4. Interface Segregation Principle (ISP)

"Do not force any client to implement an interface which is irrelevant to them."
Clients should not be compelled to implement interfaces that contain methods they do not use.
Instead of having a single large interface, it is better to have multiple smaller interfaces, each focusing on a specific set of methods relevant to a particular functionality.

// Violation of ISP
public interface IBankAccount {
    void deposit(double amount);
    void withdraw(double amount);
    double getBalance();
    void printStatement();
    void requestLoan();
}

public class BankAccount implements IBankAccount {
    private double balance;

    public void deposit(double amount) {
        // implementation details
    }

    public void withdraw(double amount) {
        // implementation details
    }

    public double getBalance() {
        // implementation details
    }

    public void printStatement() {
        // implementation details
    }

    public void requestLoan() {
        // implementation details
    }
}

The IBankAccount interface violates ISP by including methods that are not relevant to all classes that implement it.
The BankAccount class implements the entire IBankAccount interface, even though it may not need the requestLoan method.

// Adheres to ISP
// Interface for account management
public interface AccountManager {
    void deposit(double amount);
    void withdraw(double amount);
    double getBalance();
}

// Interface for account reporting
public interface AccountReporter {
    void printStatement();
}

// Interface for loan management
public interface LoanManager {
    void requestLoan();
}

Each class now depends only on the interfaces relevant to its responsibilities, adhering to ISP.

5. Dependency Inversion Principle (DIP)

"High-level modules should not depend on low-level modules. Both should depend on abstractions."
"Abstractions should not depend on details. Details should depend on abstractions."
Think of it like a restaurant. The high-level module is the restaurant, and the low-level module is the kitchen. The restaurant should not directly depend on the kitchen. Instead, both should depend on a common language, like English. The kitchen should not depend on the restaurant's specific menu. Instead, the menu should depend on the kitchen's cooking skills.

// Violates DIP
public class ShoppingMall {
    private BankAccount bankAccount;

    public ShoppingMall(BankAccount bankAccount) {
        this.bankAccount = bankAccount;
    }

    public void doPayment(String order, double amount) {
        bankAccount.withdraw(amount);
        // Process the payment
    }
}

In this example, the ShoppingMall class directly depends on the BankAccount class, which violates DIP. The ShoppingMall class is a high-level module, and the BankAccount class is a low-level module.

To fix this, we can introduce an abstraction that both the ShoppingMall and BankAccount classes can depend on.

// Adhering to DIP
public interface PaymentProcessor {
    void processPayment(double amount);
    double getBalance();
}


public class BankAccount implements PaymentProcessor {
    // implementation details
}

public class ShoppingMall {
    private PaymentProcessor paymentProcessor;

    public ShoppingMall(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }

    public void doPayment(String order, double amount) {
        paymentProcessor.processPayment(amount);
        // Process the payment
    }
}

Thank you for reading this article. I hope you found it informative and that it helps you write better, more robust code in your future projects.

3 Intermediate Python coding challenges (with solutions)

rachel — Wed, 25 Jan 2023 11:43:33 +0000

The previous Python coding challenges for beginners seem to be well-received so I decided to create another post for intermediate coding challenges. Have fun solving & don't hesistate to share your feedback or solutions in the comment section :)

1. Caesar Cipher

Background:
Caesar's cipher is a simple encryption technique, in which the plaintext character is replaced by a letter some fixed number of positions down the alphabet.

For example, with a right shift of 3, A would be replaced by D, B would become E, and so on.

Task:
Write a Python program to decode the following secret message: N qtaj uwtlwfrrnsl zxnsl Udymts, given that the key is 5.

Starter code:



ciphertext = "N qtaj uwtlwfrrnsl zxnsl Udymts"

def decrypt(ciphertext, key):
    # complete code here

decrypt(ciphertext, 5)

Sample solution:



def decrypt(ciphertext, key):
    letters = "abcdefghijklmnopqrstuvwxyz"
    letters_upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

    message = ""

    for char in ciphertext:
        if char in letters:      
            position = letters.find(char)
            new_pos = (position - key) % 26
            new_char = letters[new_pos]
            message += new_char
        elif char in letters_upper:
            position = letters_upper.find(char)
            new_pos = (position - key) % 26
            new_char = letters_upper[new_pos]
            message += new_char
        else:
            message += char
        return message

print(decrypt(cipher, 5))

2. Simple Mastermind Game

Task:
Write a program that randomly generates a 4 digit number. The user has maximum 10 tries to guess the number.

If any of the digit guessed is wrong, print "A" to indicate wrong guess.
If the digit is guessed correctly but in the wrong position, print "B".
If the digit guessed is both the correct value and position, print "C".

Starter code:



import random

def generate_number():
    # complete code here

def input_guess():
    guess = input("Enter your guess: ")
    return guess

def start_game():
    # complete code here

start_game()

Sample solution:



import random

def generate_number():
    num = random.randint(1000,9999)
    num = [int(x) for x in str(num)]
    return num

def input_guess():
    guess = input("Enter your guess: ")
    return guess

def start_game():
    tries = 0
    number = generate_number()

    while tries < 10:
        result = ""
        guess = [int(i) for i in input_guess()]

        if len(guess) != 4:
            print("Enter only 4 digit number")
            continue

        if guess == number:
            print("You won with ", tries, " attempts.")
            break

        for element in guess:
            if element in number:
                if guess.index(element) == number.index(element):
                    result+="C"
                else:
                    result+="B"
            else:
                result+="A"
        print(result)
        tries += 1

    else:   
        print("You ran out of attempts. The answer is: " , "".join(map(str, number)))   

start_game()

3. Roman Numerals & Integer Converter

Background:
The Roman numeral system consists of the following symbols:

Symbol	Value
I	1
V	5
X	10
L	50
C	100
D	500
M	1000

Numbers are constructed by combining these symbols. For instance, the number 12 can be represented by XII, since X + I + I = 10 + 1 + 1.

The following list is set of rules for Roman numerals:

Zero is not represented.
A symbol can be repeated only for three times.
Roman numerals are repeated to add value: III is equivalent to 1 +1 +1 = 3. However, only powers of 10 may be repeated in this way. Thus, VV is invalid; 5 + 5 would instead be expressed as X.
When a Roman numeral is placed after another Roman numeral of greater value, the result is the sum of the numerals. When a Roman numeral is placed before another Roman numeral of greater value, the result is the difference between the numerals.
Only I, X, and C can be used as subtractive numerals as shown:
- I can be used before V(5) and X(10) to make it IV(4) and XV(9) respectively.
- X cab be used before L(50) and C(100) to make it XL(40) and XC(90) respectively
- C can be used before D(500) and M(1000) to make them CD(400) and CM(900) respectively.

Task:
Write a program that allows users to either convert integers to roman numerals, or convert roman numerals to integers.

Starter code:



def roman_to_int(roman):
  # complete code here

def int_to_roman(int):
  # complete code here

print(" ---------- Roman Numberals Conversion ----------")  
print(" > 1 - Convert an integer to a roman numerals,")  
print(" > 2 - Convert a roman numerals to an integer.")  
option = input("Choose an option (1 or 2):")  
# complete code here

Sample solution:



def roman_to_int(s):
    roman_values = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}

    result = 0

    for i in range(len(s)):
        if i + 1 < len(s) and roman_values[s[i]] < roman_values[s[i + 1]]:
            result -= roman_values[s[i]]
        else:
            result += roman_values[s[i]]

    return result


def int_to_roman(x):
    roman_map = { 1: 'I', 4: 'IV', 5: 'V', 9: 'IX', 10: 'X', 40: 'XL', 50: 'L', 90: 'XC', 100: 'C', 400: 'XD', 500: 'D', 900: 'CM', 1000: 'M'}
    integers = list(roman_map)
    symbols = list(roman_map.values())

    i = 12
    result = ""

    while x != 0:
        if integers[i] <= x:
            result += symbols[i]
            x -= integers[i]
        else:
            i -= 1

    return result


print(" ---------- Roman Numberals Conversion ----------")  
print(" > 1 - Convert an integer to a roman numerals,")  
print(" > 2 - Convert a roman numerals to an integer.")  
option = input("Choose an option (1 or 2):")  

if option == "1":
    num = int(input("Enter an integer: "))
    print(int_to_roman(num))
elif option == "2":
    roman = input("Enter a Roman numeral: ")
    print(roman_to_int(roman))
else:
    print("Invalid input.")

A concise introduction to HTTP

rachel — Tue, 24 Jan 2023 17:04:57 +0000

What is HTTP?

The HTTP(Hyper Text Transfer Protocol) is a protocol that is responsible communication between web servers & clients. The client makes a HTTP request to a server. The server then returns a response to the client.

Why learn about HTTP?

When you visit a website, your browser make many requests to the server in the background. You can view these requests in the Chrome browser by clicking on the Network tab in Chrome Dev Tools. For example, in the image below, we can see that 35 requests were made when loading Wikipedia.

Learning about how HTTP requests allows us to optimise our server to better respond to HTTP requests.

HTTP requests

In HTTP, every request consists of a request line, headers and optionally, a body.

Request Line

The request line is the first line in the request message. It indicates the type of method, a URL address and the HTTP version number.

Example:

GET https://www.google.com/ HTTP/1.1

Headers

HTTP headers are used to send additional parameters along with the request or response. Each HTTP header is made up of a name and a value.

Example of a request header:

Host: abc.com

User-Agent: Chrome/5.0 (Windows 10)

Accept-Language: fr, de

In the above example, you’re submitting a GET request to the abc.com host for a specific resource in French or German on the Chrome browser.

Example of a response header:

Date: Tue, 24 Jan 2023 12:30:12 GMT

Server: Apache/2.2.14 (Win32)

Last-Modified: Wed, 22 Jul 2022 19:15:56 GMT

Content-Length: 50

Content-Type: text/html

Connection: Closed</code.

The response header tells us what web server and OS the host uses. If you’re requesting a file, the header will also show information about its latest modification date, the length and content type of the file. The final line indicates that the connection is closed since the request is complete.

Message Body

The message contains the data that you’re either sending or receiving, depending the request method used. For example, if you're requesting a HTML file with the GET method, the request may look like this:

Date: Tue, 24 Jan 2023 12:30:12 GMT

Server: Apache/2.2.14 (Win32)

Last-Modified: Wed, 22 Jul 2022 19:15:56 GMT

Content-Length: 50

Content-Type: text/html

Connection: Closed</code.

<!DOCTYPE html>
<html>
    <head>
        <title>Title of the document</title>
    </head>

    <body>
        The content of the document......
    </body>
</html>

The body of a HTTP request or repsonse comes right after the header.

HTTP Methods

Now that we have learnt about how a HTTP request or response is made, it's time to take a look at different HTTP methods. Some commonly used HTTP methods are:

Method	Description	Example
GET	retreive data from server	loading a HTML page, JSON data, images, etc.
POST	submit data to the server	submitting contact form
PUT	update data that is already on ther server	editing a blog post
DELETE	delete data from the server	deleting a file

HTTP Response Status Codes

Every HTTP response message contains a HTTP status code, which tells us about the result of the request. Responses can be classified into five groups:

Status Codes	Type
100 – 199	Informational
200 – 299	Successful
300 – 399	Redirection
400 – 499	Client Error
500 – 599	Server Error

Common status codes:

Status Code	Description
200 OK	Request successful
201 Created	Request successful & resource created
301 Moved Permanently	Location of requested resource has been moved to another URL
400 Bad Request	Client Error (eg. wrong request syntax)
401 Unauthorized	No valid authentication credentials for the requested resource
404 Not Found	Server cannot find requested resource
500 Internal Server Error	Server encountered something unexpected

HTTPS

HTTPS (Hypertext Transfer Protocol Secure), in short, is the secure version of HTTP. It is not a separate protocol from HTTP. It is simply using TLS/SSL encryption over the HTTP protocol, which enables clients to safely transmit sensitive data to the server.

Any website, especially those that require login credentials, should use HTTPS. Modern web browsers such as Chrome and Firefox flag all non-HTTPS websites as not secure.

Polymorphism - [Java OOP #5]

rachel — Tue, 20 Dec 2022 16:32:31 +0000

Polymorphism refers to the ability of a method to have multiple implementations based on what object is passed to it. Polymorphism can be divided into two types: runtime and compile-time.

Runtime Polymorphism

Runtime polymorphism, also known as dynamic polymorphism, is achieved by method overriding. The concept of method overriding was introduced in the previous article of this OOP series.

Runtime polymorphism is resolved during runtime, in which the JVM decides which method to invoke. Take a look at the example below:

Here, "obj" is a reference variable of the Cat superclass, but it is pointing to the object of the Tiger subclass. Hence the makeSound() method of the Tiger class is called.

Compile Time Polymorphism

Compile time polymorphism, also known as static polymorphism, is acheived by method overloading. Method overloading is when different methods possess the same name but different parameters. This can be done by changing the number, data types and order of parameters.

Try and run the sample code below and observe the results. For better understanding, you can create your own methods and experiment with different paramters.

class Test {

    public static int sum(int x, int y) {
        return x + y;
    }

    public static int sum(int x, int y, int z) {
        return x + y + z;
    }

    public static double sum(double x, int y) {
        return x + y;
    }

    public static double sum(int x, double y) {
        return x + y;
    }
}

class Main {
    public static void main(String[] args) {
        // invokes the first sum() method
        System.out.println(Test.sum(1, 2)); 

        // invokes the second sum() method
        System.out.println(Test.sum(1, 2, 3));

        // invokes the third sum() method
        System.out.println(Test.sum(1.0, 2));

        // invokes the fourth sum() method
        System.out.println(Test.sum(1, 2.0));
    }
}

Inheritance & Method Overriding - [Java OOP #4]

rachel — Thu, 06 Oct 2022 02:45:10 +0000

Inheritance

The word "inheritance", is defined as deriving something from one's ancestors. Similarly, in Java, this concept of inheritance can be applied as when a child class(known as a subclass) inherits attributes and methods from a parent class(known as a superclass).

Inheritance is useful when we want to create objects that have similar characteristics, but each object to have their own additional features. For example, we can have a Bicycle superclass, but we want multiple subclasses such as MountainBicycle and RoadBicycle to define specific types of bicycles.

In the example below, we will create a Cat subclass from the Animal superclass by using the extends keyword.

class Animal {
    public String name;
    public int age;

    Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println("Nom nom.");
    }

    public String toString() {
        return ("Name: " + name + "Age: " + age);
    }
}

class Cat extends Animal {
    public String colour;

    Cat(String name, int age, String colour) {
        // invoking superclass' constructor
        super(name, age);
        this.colour = colour;
    }

    // Overriding toString() method to print more info
    @Override
    public String toString() {
        return ("Name: " + name + "Age: " + age + "Colour: " + colour);
    }
}

public class Test {
    public static void main(String args[]) {
        Cat cat1 = new Cat("Oatmew", 3, "orange");
        System.out.println(cat1.toString());
        // calling a method from superclass
        cat1.eat();
    }
}

Things to note:

name and age in Animal class were set to public because if it was private, its subclasses cannot access them.
Object cat1 has access to the eat() method. This is because the Cat class inherits the methods of the Animal class.
The super keyword is used in subclasses to access superclass members. It can be used to access attributes, constructors and methods.
@Override is an annotation used to inform the compiler that the subclass is overwriting the superclass. It is useful because it extracts a warning from the compiler if the method did not actually override anything and it also improves code readbility. It is not mandatory but generally a good practice to use it.

Types of inheritance

On the basis of class, there are 3 types of inheritance in Java:

Single

In a single level inheritance, a superclass only has one subclass.

Multilevel

In a multilevel level inheritance, a superclass can have a subclass and the subclass can have its own subclass, so on and so forth. However, each subclass only has access to its immediate parent class.

Hierarchical

In a hierarchical inheritance, a single class serves as the superclass to multiple subclasses.

Method Overriding

Method overriding is done when a subclass has a same method but with different implementation as the parent class. The rules for using method overriding are:

Only inherited methods can be overriden.
The overriding method must have the same name, paramters and return type as the overriden method.
A final, static or private method cannot be overriden.

Modifiers & Encapsulation - [Java OOP #3]

rachel — Mon, 26 Sep 2022 08:03:17 +0000

In Java, there are two types of modifiers: access modifiers and non-access modifiers.

Access Modifiers

Access modifiers are used to specify the scope of classes, constructors, methods, variables, etc. There are 4 types of access modifiers in Java:

Access Modifier	Description
default	accessible within the same package
`public`	accessible for all classes
`private`	accessible within the declared class
`protected`	accessible within the package or all subclasses

Examples:

default

package p1;

// class Example is accessible within package p1
class Example {
    void display() {
        System.out.println("Hello");
    }
}

public

// class A can be accessed anywhere
public class A {
    // display method can be accessed anywhere
    public void display() {
        System.out.println("Hello");
    }
}

class B {
    public static void main(String args[]) {
        // creating object of public class A
        A obj = new A();

        // calling public display() method
        obj.display();
    }
}

private

class A { 
    // variable x can only be accessed in class A
    private int x = 1;  

    // display() method can only be accessed in class A
    private void display() {
        System.out.println("Hello");
    }
}  

public class Example {  
    public static void main(String args[]){  
        // object can be created as class A has default access
        A obj=new A();  
        System.out.println(obj.x); // compile time error  
        obj.display(); // compile time error  
    }  
}

protected

package p1;  

public class A{  
    /* display() can be accessed by package p1 
    / or subclasses of A in another package */
    protected void display(){
        System.out.println("Hello");
    }  
}

// class B is a subclass of A
class B extends A{  
    public static void main(String args[]){  
        B obj = new B();  
        obj.display();  
    }  
}

Non-access Modifiers

Non-access modifiers specifies the characteristics of classes, methods, variables, etc. Some commonly used non-access modifiers are:

Non-access Modifier	Description
`final`	final classes cannot be inherited final methods cannot be overriden final variables can only be initialised once
`static`	Static methods or fields are a part of the class and not an object. They can be called without creating an object of the class.

Examples:

final

public class Example {
    final double PI = 3.14;

    public static void main(String[] args) {
        Example obj = new Example();
        obj.PI = 3; // compile time error
    }
}

static

public class Example {
    static void myStaticMethod() {
        System.out.println("Static methods can be called without creating objects");
    }

    public static void main(String[] args) {
        myStaticMethod(); // calling the static method
    }
}

Encapsulation

Encapsulation is defined as the wrapping up of data under a single unit. Encapsulation allows data hiding, which is useful when we do not want the user to have have direct access to data in the class.

To achieve encapsulation, declare variables as private and provide public setter and getter methods to modify the variables.

Example:

public class Person {
    private String name; 

    public String getName() {
      return name;
    }

    public void setName(String newName) {
      this.name = newName;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.setName("Bob"); // initialise name using setter
        person1.name = "John";  // error as name is private
    }
}

Java Constructors - [Java OOP #2]

rachel — Tue, 20 Sep 2022 03:41:43 +0000

In the previous article of this Java OOP Series, I briefly mentioned how we can use a constructor to initialise objects. In this article, we will further discuss about the different types of constructors.

Recap

A Constructor is a method that is used to initialise objects. It is called once whenever an object of a class is created.

Unlike Java methods, a constructor must have the same name as the class and it does not have a return type.
Take note that it is not necessary to write a constructor for a class as the Java compiler creates a default constructor if there isn't any in the class.

Types of constructors

Java constructors can be categorised into no-argument constructors or parameterised constructors. The default constructor is a no-argument constructor.

No-argument constructors

A no-argument constructor is a constructor that does not have any parameters.

class Student {
    // fields
    private String name;

    // constructor
    Student() {
        name = "Alice"; 
    }

    public static void main(String[] args) {
        // constructor is invoked while
        // creating an object of the Student class
        Student newStudent = new Student();
        System.out.println("The name is " + newStudent.name);
    }
}

Parameterised constructors

Parameterised constructors are constructors that takes one or more parameters.

class Student {
  String name;
  int age;

  Student(String name, int age) {
    this.name = name;
    this.age = age;
    System.out.println(name + " is " + age + " years old.");
  }

  public static void main(String[] args) {
    Student Student1 = new Student("Bob", 12);
    Student Student2 = new Student("Krystal", 14);
  }
}

The this keyword is used to avoid ambiguity because Java compiler cannot differentiate between the variable and parameter if they both have same names. this keyword will refer to the current object inside the constructor.

Default constructors

If we do not create any constructors, the Java compiler creates a default constructor during the execution of the program. It initialises any uninitialised instance variables with default values:

Variable Type	Default Value
boolean	false
int byte short	0
float double	0.0
char	\u0000
Reference types	null

class Example {

  int a;
  boolean b;

  public static void main(String[] args) {
    // call the constructor
    Example obj = new Example();

    System.out.println("Default Value:");
    System.out.println("a = " + obj.a);
    System.out.println("b = " + obj.b);
  }
}

5 coding challenges for beginners (with solutions in Python)

rachel — Tue, 13 Sep 2022 07:12:46 +0000

Here are some fun beginner-friendly coding problems that I came across recently. I hope that this article can help you improve your understanding and motivate you to learn.

1. Number of integers in a string

Given a string, return the number of integers present. For example, the string "My favourite number is 17 and 30" has 2 integers.

Tips:

Break the string down into individual words.
Use Python's built in functions to check for the type of each word.

Solution:

def num_of_integers(str):

    count = 0 # initialise count

    str = str.split() # split the string into list of words

    for i in range(len(str)):
        if(str[i].isdigit()): #check if the word is an integer
            count += 1 # increment count

    return count

print(num_of_integers("My favourite number is 17 and 30"))

2. Palindrome checker
Write a function that checks is a given word is a palindrome(a word that is read the same forward and backward, for example, "bob", "abba", "radar"), assuming that input will be in lowercase letters.

Solution:

# Method 1: Iterative solution
def palindrome(str):
    for i in range(int(len(str) / 2)):
        if (str[i] == str[len(str)-1]):
            return True
    return False

# Method 2: Using Python's built in function
def palindrome(str):
    return str == str[::-1] # compares the string and its reverse

3. Zip two lists

Write a custom zip function that replicates Python's built in zip() function.

Solution:

def custom_zip(list1, list2):
    result = []
    for i in range(len(list1)):
        result.append((list1[i], list2[i]))
    return result

print(custom_zip([0, 1, 2, 3],[5, 6, 7, 8]))

4. Print a staircase
Given a positive integer n, print a staircase of height and width of n using "#" and spaces. An example is shown below:

n = 4
#
##
###
####

Tips:

Use for loops
Think of how many "#" and white spaces you want in each row

Solution:

def staircase(n):
    for i in range(n):
        for x in range(i+1):
            print("#", end = "") 
        for y in range(n-i-1):
            print(" ", end = "")
        print()

staircase(4)

Explanation:

For the first row, you want 1 "#" and (n - 1) white spaces. For the second row, you want 2 "#" and (n - 2) white spaces and so on...
The nested for loop is used for displaying the "#" and white spaces for each line.
Once each line is completed, it will go to the outer loop then print the next line.

5. Recursive Pascal's triangle

Given a row and column number, write a recursive function that returns the corresponding value of the specified row and column in the Pascal's triangle as shown below:

Tips:

The values are formed by adding together the two numbers just above to the left and right of each position in the triangle.
There are a few base cases to consider.
Number of columns should not be larger than number of rows.

Solution:

def pascal_triangle(row, col):
    if (row >= col):
        if (col == 0 or row == 0 or row == col):
            return 1
        else:
            return pascal_triangle(row-1, col-1) + pascal_triangle(row-1, col) 
    else:
        return 0

print(pascal_triangle(3,0))
print(pascal_triangle(3,1))
print(pascal_triangle(3,2))
print(pascal_triangle(3,3))

Hope you had fun trying out these challenges! Feel free to share your solutions and any comments regarding the post.

Understanding classes & objects - [Java OOP #1]

rachel — Sun, 04 Sep 2022 16:52:08 +0000

Introduction

Object oriented programming(OOP) is a programming methodology that is based on the concept of objects, which are components that possess an identity, a state and a behaviour.

They can mimic real-world entities. To illustrate this, I will be using the typical car example, sorry for the lack of creativity XD

Say we want to use a car in your program. To do this, we have to define a Car class. This class acts as a template for what a car looks like and what it can do. Using this template, we can create different objects of type 'Car' and describe their features and functionalities. In short, you can think of the class as a blueprint and the object as an embodiment of a class.

Terminologies

Classes are user-defined templates used to create and define objects.
Objects are instances(results) of a of class. All the instances of the same class share the attributes and the behavior of the class.
Identity refers to the characteristic that uniquely identifies the object, typically implemented via a unique ID or memory addresss.
State refers to the properties of an object.
Behaviour refers to the behaviours(functionalities) of an object.

Creating a class

We create classes in Java by using the class keyword.

class Car {

    // Fields
    String model;
    String colour;
    int milesDriven;
    double gasInTank;

    // Methods
    void addGas(double amount) {
        gasInTank = gasInTank + amount; 

    }

    int getMilesDriven() {
        return milesDriven;
    }

}

fields is another name for variables and methods is synonymous to functions.
Class names are capitalised by convention.

Declaring an object

Declaring an object is also called instantiating a class. The object is known as the instance of a class. For example, we have a class Animal, and we want to declare an object Koala of type Animal. We say that Koala is an instance of the Animal class.

// Syntax
type name;

// Example
int testScore; // primitive type
Animal koala; //reference type

Simply declaring a reference variable does not create an object. Its value will be undetermined until we initialise it.

Initialising an object

Initialising an object involves assigning a value into an object. In Java, we initialise objects by using the new keyword followed by a call to a constructor.

public class Cat {
   // Constructor with one parameter, name
   public Cat(String name) {
      // Fields
      String name;
      // Methods
      ...
   }

   public static void main(String []args) {
      // Creating an object named myCat of type Cat
      Cat myCat = new Cat( "Bingus" );
   }
}

We have used the new keyword along with the constructor of the class to create an object. Here, Cat() is the constructor of class Cat.

Constructors in Java is a special method used for initialising objects.
They have the same name as the class.
It may or may not have paramters.
If we do not define any constructors, Java will initialize uninitialized instance variables with default values:

Variable Type	Default Value
boolean	false
int	0
float double	0.0
char	\u0000
Reference types	null

Accessing instance variables & methods

We can access the variables & methods of an instance by using the . notation as follows:

// Syntax
// Creating an object
className objectName = new className();

// Calling a variable
objectName.variableName;

// Calling a class method
objectName.methodName();

Exercise

Try creating a Bank Account class with these requirements:

properties: name, account number, balance
methods: withdraw, deposit, check balance.

Then, create a test account to deposit some money and check the balance.

Try it yourself before referring to the example solution.

public class Account {

    // fields
    private String name;
    private int number;
    private double balance;

    // constructor
    public Account (String accountName, int accountNumber, float accountBalance){  
        name = accountName;
        number = accountNumber;
        balance = accountBalance;
    }

    // method to withdraw money if balance is sufficient
    public void withdraw(int amount) {
        if (amount < balance) {
            balance = balance - amount;
        } else {
            System.out.println("Insufficient balance.");
        }
    }

    // method to deposit money into account
    public void deposit(int amount) {
        balance = balance + amount;
    }

    // method that displays the balance
    public void checkBalance() {
        System.out.printf("Balance is: %.2f", balance);
    }

    public static void main(String[] args) {
        Account myAccount = new Account("Rachel", 1234, 10000000);
        myAccount.deposit(10000000);
        myAccount.checkBalance(); // Prints Balance is: 20000000.00
    }
}

Introduction to Java for beginners

rachel — Fri, 26 Aug 2022 03:17:00 +0000

Overview

Java is a high level OOP language. It is one of the most popular languages due to its platform independent nature, which is especially important for softwares that are required to work on multiple operating systems. This is because Java code are compiled to bytecode that can be executed on any Java virtual machine(JVM) across different platforms without recompilation.

Introduction to Java

Your first Java application: Hello World

// This is a comment

/* This is a 
multi-line comment */

/**
 * The HelloWorldApp class implements an application 
 * that prints the string "Hello World!" to the screen.
 */
class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

Every program in Java is enclosed within a class definition. In this case, the class name is HelloWorld and the class definition is class HelloWorld {...}.
The main method is the entry point of any Java program where the JVM will begin program execution.
Don't worry if you don't understand the meaning of class, public, static for now. It will be discussed in the OOP articles which will be posted in the future.

Java JDK, JRE, JVM
In short, we use the Java Development Kit(JDK) to build Java applications. When you download the JDK, it comes with a compiler, the Java Runtime Environment(JRE). The JRE provides a library of classes and the Java Virtual Machine(JVM) which is used to execute Java bytecode.

Java Variables

// Method 1 to declare variables
int num = 7;

// Method 2 to declare variables
int num;
num = 7;

// Assigning a new value
num = 10; // num is now 10

// To make this variable unchangeable, use the 'final' keyword
final int fixedNum = 1;
fixedNum = 2; // Generates an error

Java Data Types
The data type should be specified during a variable declaration. Java data types can be categorised into 2 groups, namely primitive types and reference types.

Primitive data types:

Data Type	Size(bits)	Description
byte	8	Whole numbers from -128 to 127
short	16	Whole numbers from -32,768 to 32,767
int	32	Whole numbers from -2³¹ to 2³¹-1
long	64	Whole numbers from -2⁶³ to 2⁶³-1
float	32	Fractional numbers with 6-7 decimal digits precision
double	64	Fractional numbers with 15-16 decimal digits precision
boolean.	1	true or false values
char	16	a single Unicode character

Reference data types:

Primitive types are basic types that stores values. Non-primitive types, also known as reference types, store the address of dynamically created objects. They provide access to the objects stored in the memory. Say we have a class named Animal and we create an object cat, then the variable cat is considered a reference type. Some examples of reference types are String, Array, class, interface, etc.

Java Type Casting
Type casting is assigning a value of one primitive data type to another primitive data type. In Java, there are 2 types of casting:

Widening casting (implicit) - It happens automatically when we try to store a value of smaller size type to a larger size type.
Narrowing casting (explicit) - It is done manually when we want to convert a value of larger size type to a smaller size type.

// Example of widening casting: short(2 bytes) to int(4 bytes)
short x = 1; 
int y = x;

// Example of narrowing casting
int x = 1;
short y = (short) x;

Java Input and Output

There are a few ways to display the ouput to the standard output(screen).

Method	Description
print()	prints string inside the quotes
println()	prints string inside the quotes and inserts a new line
printf()	print formatted strings according to format specifiers

Java also provides several ways to get user input. The most simple way is to create an object from the Scanner class as follows:

// Import java.util.Scanner package to use the Scanner class
import java.util.Scanner;

// Create an object of Scanner
Scanner input = new Scanner(System.in);

// Take input from the user
int number = input.nextInt();

// Print user input
System.out.println("You entered " + number);

Java Flow Control

If-else statements:

if (condition) { 
    // statement
} else if (condition) {
    // statement
} else (condition) {
    // statement
}

Ternary operator (shorthand for if-else statements):

// Syntax: (condition) ? Expression 1 : Expression 2

/* Example: If marks is more than 40, assign grade as "Pass", 
otherwise assign it as "Fail" */
String grade = (mark > 40) ? “Pass” : “Fail”;

Switch statements:

/* Syntax: 
switch (expression) {
  case value1:
    // code
    break;
  case value2:
    // code
    break;
  ...
  default:
    // default statements
}
*/

// Example: 
char size = "M"

switch (size) {
      case "S":
        size = "small";
        break;

      case "M":
        size = "Medium";
        break;

      case "L":
        size = "Large";
        break;

      default:
        size = "Unknown";
        break;
}

break statements are used to "jump out" of switch statements or loops and continue statements skip the current iteration of a loop if the specified condition is true.

While loops

// While loop syntax
while (condition) {
    // code block to be executed
}

// Do...while loop syntax
do {
  /* Code here will be executed once before checking if it
     it true or false, then it will repeat the loop as long as
     it satisfies the condition. 
  */
}
while (condition);

For loops

// For loop syntax
for (statement 1; statement 2; statement 3) {
  // code block to be executed
}

// Example
int[] numbers = {1, 2, 3, 4};

for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

// For...each loop syntax
for (type variableName : arrayName) {
  // code block to be executed
}

// Example
int[] numbers = {1, 2, 3, 4};

for (int number : numbers) {
    System.out.println(number);
}

Java Arrays
Arrays are used to store a list of objects of the same type.

// Declaring an array to store marks
int[] marks;

// Allocate memory 
marks = new int[3]

// We can declare and allocate memory in one line
int[] marks = new int[3];

// Initialise the array
marks = { 75, 80, 90 }

Binary Search in minutes

rachel — Wed, 13 Jul 2022 06:46:00 +0000

Binary search is an algorithm that returns the index of a given element within a sorted array. To put it simply, it does this by repreatedly halving the list until the number of possible locations of the wanted element is reduced to one.

How binary search works?

Say we want to find the position of the element 38 from the following array:
First we find the midpoint of the array. We can find the midpoint by using the formula mid = (low + high) / 2.
Compare 38 with the middle element. Since 25 is less than 38, we omit the first half. For the second half, low = mid + 1.
Repeat until mid points to the target element and return the index, which in this case is 6.

Implementation in Python

# iterative approach
def iterative_binary_search(list, target):
    low = 0
    high = len(list) - 1

    while high > low:
        mid = math.floor((low + high) / 2)
        if list[mid] == target:
            return mid
        elif list[mid] < target:
            low = mid + 1
        else:
            high = mid - 1

    return -1

# recursive approach
def recursive_binary_search(list, target, low, high):
    if low < high:
        mid = math.floor((low + high) / 2)

        if list[mid] == target:
            return mid
        elif list[mid] < target:
            return recursive_binary_search(list, target, mid + 1, high)
        else:
             return recursive_binary_search(list, target, low, mid - 1)

    return -1

Time complexity of binary search

Case	Time Complexity
Best	O(1)
Average	O(log n)
Worst	O(log n)

Best case is when target element is positioned exactly in the middle.
Number of elements = 2^depth because each element branches into 2 more elements.
Worst case is when the searches the deepest level of the tree.
Depth is approximately log2n, where n is the number of elements.

Space complexity of binary search

Iterative binary search requires three pointers(to keep track of the starting, middle and end points) regardless of the size of the array. Hence, its space complexity of is O(1).
On the other hand, recursive binary search does not have any loops and the new values are passed onto the next recursive call. The time complexity for recursive binary search is O(log n).