Elham Badri

Splitting monolithic applications into microservices

microservices have many benefits over monolithic applications such as:

• Improved scalability
• Easier Maintenance
• Easier to develop

This is due to the fact that each service is seperate from the rest making it easier to developers to increase the number of instances, fix bugs in each service, and not have to worry about too many dependencies when developing new features

                  
# Monolithic Python Flask Application

from flask import Flask, render_template

app = Flask(__name__)

# Routes for different functionalities
@app.route('/')
def home():
    return render_template('home.html')

@app.route('/products')
def products():
    return render_template('products.html')

@app.route('/orders')
def orders():
    return render_template('orders.html')

if __name__ == '__main__':
    app.run(debug=True)

=========================

# Catalog Microservice

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/products')
def products():
    # Product-related logic
    return render_template('products.html')

if __name__ == '__main__':
    app.run(debug=True, port=5001)


=========================

# Order Microservice

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/orders')
def orders():
    # Order-related logic
    return render_template('orders.html')

if __name__ == '__main__':
    app.run(debug=True, port=5002)

                  
                

In this code, a monolithic api handles both catalog and orders

By splitting up this into 2 seperate microservices, you can decouple the logic, gaining all the benefits of using microservices

Improving Query Performance with Bind Variables

As a software developer, I am always looking for ways to improve the performance of my code. One technique I have found effective is the use of bind variables in SQL statements.

Bind variables are placeholders for values in a SQL statement. They are used to improve the performance of queries by allowing the database server to cache the execution plan for the statement.

For example, consider the following Java code that uses a Prepared Statement with a bind variable to retrieve rows from a table:

                  
                    // Create the prepared statement
                    String sql = "SELECT * FROM employees WHERE salary > ?";
                    pstmt = conn.prepareStatement(sql);
              
                    // Bind the value to the first bind variable
                    pstmt.setInt(1, 100);
              
                    // Execute the statement
                    rs = pstmt.executeQuery();
                  
                

In this code, a Prepared Statement object is created with a SELECT statement that includes a bind variable `?`. The value for the bind variable is then set using the `setInt` method, and the statement is executed using the `executeQuery` method.

By using bind variables in this way, I was able to improve the performance of my queries by allowing the database server to cache the execution plan for the statement. This helped to reduce the load on the database server and improve the overall performance of my application.