Upload 3 files

pages/cohesion.py

@@ -0,0 +1,168 @@
+import streamlit as st
+from utils.code_examples import cohesion_examples
+from utils.quiz import cohesion_quiz
+
+st.title("Cohesion in Software Architecture")
+
+st.write("""
+Cohesion refers to the degree to which the elements within a module belong together.
+High cohesion is generally associated with good software design.
+""")
+
+st.subheader("Types of Cohesion")
+st.write("""
+1. **Functional Cohesion**: All elements of the module are related to the performance of a single function.
+2. **Sequential Cohesion**: Elements of a module are involved in activities where output from one element serves as input to another.
+3. **Communicational Cohesion**: Elements of a module operate on the same data.
+4. **Procedural Cohesion**: Elements of a module are involved in different and possibly unrelated actions that must be performed in a specific order.
+5. **Temporal Cohesion**: Elements are related by the fact that they are processed at a particular time in program execution.
+6. **Logical Cohesion**: Elements perform similar operations, but these operations are unrelated.
+7. **Coincidental Cohesion**: Elements have no meaningful relationship to one another.
+""")
+
+st.subheader("Examples of Cohesion")
+
+for i, (title, description, python_code) in enumerate(cohesion_examples, 1):
+    st.markdown(f"### Example {i}: {title}")
+    st.write(description)
+    
+    # Create tabs for Python and Java examples
+    python_tab, java_tab = st.tabs(["Python", "Java"])
+    
+    with python_tab:
+        st.code(python_code, language="python")
+    
+    with java_tab:
+        if title == "Functional Cohesion":
+            java_code = """
+class UserAuthentication {
+    private String username;
+    private String password;
+
+    public UserAuthentication(String username, String password) {
+        this.username = username;
+        this.password = password;
+    }
+
+    public String hashPassword() {
+        // Hash the password
+        return "hashed_" + password;
+    }
+
+    public boolean checkPasswordStrength() {
+        // Check if the password meets security requirements
+        return password.length() >= 8;
+    }
+
+    public boolean authenticate() {
+        // Authenticate the user
+        return username != null && password != null;
+    }
+}
+"""
+        elif title == "Sequential Cohesion":
+            java_code = """
+class OrderProcessor {
+    public Order processOrder(Order order) {
+        Order validatedOrder = validateOrder(order);
+        Order calculatedOrder = calculateTotal(validatedOrder);
+        return submitOrder(calculatedOrder);
+    }
+
+    private Order validateOrder(Order order) {
+        // Validate the order
+        order.setValid(true);
+        return order;
+    }
+
+    private Order calculateTotal(Order order) {
+        // Calculate the total price
+        order.setTotal(100.0); // Dummy calculation
+        return order;
+    }
+
+    private Order submitOrder(Order order) {
+        // Submit the order to the system
+        order.setSubmitted(true);
+        return order;
+    }
+}
+"""
+        elif title == "Communicational Cohesion":
+            java_code = """
+class UserManager {
+    private User userData;
+
+    public UserManager(User userData) {
+        this.userData = userData;
+    }
+
+    public boolean validateUser() {
+        // Validate user data
+        return userData.getName() != null && userData.getEmail() != null;
+    }
+
+    public void saveUser() {
+        // Save user to database
+        System.out.println("User saved: " + userData.getName());
+    }
+
+    public void sendWelcomeEmail() {
+        // Send welcome email to user
+        System.out.println("Welcome email sent to: " + userData.getEmail());
+    }
+}
+"""
+        st.code(java_code, language="java")
+
+st.subheader("Interactive Exercise: Identify Cohesion Types")
+st.write("Analyze the following code snippets and identify the type of cohesion present.")
+
+code1 = """
+class UserManager:
+    def create_user(self, username, email):
+        # logic to create user
+        pass
+
+    def delete_user(self, user_id):
+        # logic to delete user
+        pass
+
+    def update_user(self, user_id, new_data):
+        # logic to update user
+        pass
+"""
+
+code2 = """
+class ReportGenerator:
+    def generate_sales_report(self):
+        # logic for sales report
+        pass
+
+    def generate_inventory_report(self):
+        # logic for inventory report
+        pass
+
+    def send_email(self, report):
+        # logic to send email
+        pass
+"""
+
+st.code(code1, language="python")
+user_answer1 = st.selectbox("What type of cohesion is present in the first example?", 
+                            ("Functional", "Sequential", "Communicational", "Procedural", "Temporal", "Logical", "Coincidental"))
+
+st.code(code2, language="python")
+user_answer2 = st.selectbox("What type of cohesion is present in the second example?", 
+                            ("Functional", "Sequential", "Communicational", "Procedural", "Temporal", "Logical", "Coincidental"))
+
+if st.button("Check Answers"):
+    if user_answer1 == "Functional" and user_answer2 == "Logical":
+        st.success("Correct! The UserManager class shows functional cohesion, while the ReportGenerator class shows logical cohesion.")
+    else:
+        st.error("Not quite. Try again!")
+
+st.markdown("---")
+
+st.subheader("Quiz: Cohesion Concepts")
+cohesion_quiz()

pages/coupling.py

@@ -0,0 +1,148 @@
+import streamlit as st
+from utils.code_examples import coupling_examples
+
+st.title("Coupling in Software Architecture")
+
+st.write("""
+Coupling refers to the degree of interdependence between software modules. 
+Low coupling is typically a sign of a well-structured computer system and a good design.
+""")
+
+st.subheader("Types of Coupling")
+st.write("""
+1. **Tight Coupling**: Modules are highly dependent on each other.
+2. **Loose Coupling**: Modules are relatively independent of each other.
+""")
+
+st.subheader("Examples of Coupling")
+
+for i, (title, description, python_code) in enumerate(coupling_examples, 1):
+    st.markdown(f"### Example {i}: {title}")
+    st.write(description)
+    
+    # Create tabs for Python and Java examples
+    python_tab, java_tab = st.tabs(["Python", "Java"])
+    
+    with python_tab:
+        st.code(python_code, language="python")
+    
+    with java_tab:
+        if title == "Tight Coupling":
+            java_code = """
+class Database {
+    public User getUser(int userId) {
+        // database logic here
+        return new User(userId);
+    }
+}
+
+class UserService {
+    private Database db;
+
+    public UserService() {
+        this.db = new Database();
+    }
+
+    public User getUserInfo(int userId) {
+        return db.getUser(userId);
+    }
+}
+"""
+        elif title == "Loose Coupling":
+            java_code = """
+class Database {
+    public User getUser(int userId) {
+        // database logic here
+        return new User(userId);
+    }
+}
+
+class UserService {
+    private Database db;
+
+    public UserService(Database database) {
+        this.db = database;
+    }
+
+    public User getUserInfo(int userId) {
+        return db.getUser(userId);
+    }
+}
+"""
+        elif title == "Decoupling with Interfaces":
+            java_code = """
+interface DatabaseInterface {
+    User getUser(int userId);
+}
+
+class DatabaseImpl implements DatabaseInterface {
+    public User getUser(int userId) {
+        // database logic here
+        return new User(userId);
+    }
+}
+
+class UserService {
+    private DatabaseInterface db;
+
+    public UserService(DatabaseInterface database) {
+        this.db = database;
+    }
+
+    public User getUserInfo(int userId) {
+        return db.getUser(userId);
+    }
+}
+"""
+        st.code(java_code, language="java")
+
+st.subheader("Interactive Exercise: Identify Coupling Issues")
+st.write("Analyze the following code snippets and identify the type of coupling present.")
+
+code1 = """
+class Database:
+    def get_user(self, user_id):
+        # database logic here
+        pass
+
+class UserService:
+    def __init__(self):
+        self.db = Database()
+
+    def get_user_info(self, user_id):
+        return self.db.get_user(user_id)
+"""
+
+code2 = """
+class Database:
+    def get_user(self, user_id):
+        # database logic here
+        pass
+
+class UserService:
+    def __init__(self, database):
+        self.db = database
+
+    def get_user_info(self, user_id):
+        return self.db.get_user(user_id)
+"""
+
+st.code(code1, language="python")
+user_answer1 = st.radio("What type of coupling is present in the first example?", 
+                        ("Tight Coupling", "Loose Coupling"))
+
+st.code(code2, language="python")
+user_answer2 = st.radio("What type of coupling is present in the second example?", 
+                        ("Tight Coupling", "Loose Coupling"))
+
+if st.button("Check Answers"):
+    if user_answer1 == "Tight Coupling" and user_answer2 == "Loose Coupling":
+        st.success("Correct! The first example shows tight coupling, while the second shows loose coupling.")
+    else:
+        st.error("Not quite. Try again!")
+
+st.markdown("---")
+
+st.subheader("Quiz: Coupling Concepts")
+from utils.quiz import coupling_quiz
+coupling_quiz()

pages/monolithic.py

@@ -0,0 +1,154 @@
+import streamlit as st
+from utils.code_examples import monolithic_example
+from utils.quiz import monolithic_quiz
+
+st.title("Monolithic Architecture")
+
+st.write("""
+Monolithic architecture is a traditional unified model for designing software programs.
+In this architecture, all components of the application are interconnected and interdependent,
+forming a single, indivisible unit.
+""")
+
+st.subheader("Characteristics of Monolithic Architecture")
+st.write("""
+1. **Single Codebase**: The entire application is contained within a single codebase.
+2. **Shared Database**: All modules typically share a single database.
+3. **Tightly Coupled**: Components are interconnected and interdependent.
+4. **Single Deployment Unit**: The entire application is deployed as a single unit.
+""")
+
+st.subheader("Advantages and Disadvantages")
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown("**Advantages**")
+    st.write("""
+    - Simple to develop
+    - Easy to deploy
+    - Good performance (no network latency between components)
+    """)
+
+with col2:
+    st.markdown("**Disadvantages**")
+    st.write("""
+    - Can become complex as the application grows
+    - Difficult to scale individual components
+    - Technology stack is shared across the entire application
+    - Changes can affect the entire system
+    """)
+
+st.subheader("Example of a Monolithic Architecture")
+
+st.write("Here's a simplified example of a monolithic e-commerce application with a product recommendation system:")
+
+# Create tabs for Python and Java examples
+python_tab, java_tab = st.tabs(["Python", "Java"])
+
+with python_tab:
+    st.code(monolithic_example, language="python")
+
+with java_tab:
+    java_monolithic_example = """
+import java.util.*;
+
+class EcommerceApp {
+    private Map<String, User> users = new HashMap<>();
+    private Map<Integer, Product> products = new HashMap<>();
+    private Map<Integer, Order> orders = new HashMap<>();
+    private Map<Integer, Payment> payments = new HashMap<>();
+    private Map<String, List<String>> userPreferences = new HashMap<>();
+
+    public void registerUser(String username, String password) {
+        users.put(username, new User(username, password));
+        userPreferences.put(username, new ArrayList<>());
+    }
+
+    public void addProduct(int productId, String name, double price, String category) {
+        products.put(productId, new Product(productId, name, price, category));
+    }
+
+    public Integer createOrder(String user, int productId, int quantity) {
+        if (users.containsKey(user) && products.containsKey(productId)) {
+            int orderId = orders.size() + 1;
+            orders.put(orderId, new Order(orderId, user, productId, quantity));
+            userPreferences.get(user).add(products.get(productId).getCategory());
+            return orderId;
+        }
+        return null;
+    }
+
+    public boolean processPayment(int orderId, String paymentMethod) {
+        if (orders.containsKey(orderId)) {
+            payments.put(orderId, new Payment(paymentMethod, "completed"));
+            return true;
+        }
+        return false;
+    }
+
+    public List<Product> recommendProducts(String user, int numRecommendations) {
+        if (!userPreferences.containsKey(user) || userPreferences.get(user).isEmpty()) {
+            return new ArrayList<>(products.values()).subList(0, Math.min(numRecommendations, products.size()));
+        }
+
+        List<String> userCategories = userPreferences.get(user);
+        String mostCommonCategory = getMostCommonCategory(userCategories);
+
+        List<Product> recommendedProducts = products.values().stream()
+                .filter(p -> p.getCategory().equals(mostCommonCategory))
+                .limit(numRecommendations)
+                .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
+
+        if (recommendedProducts.size() < numRecommendations) {
+            List<Product> otherProducts = products.values().stream()
+                    .filter(p -> !p.getCategory().equals(mostCommonCategory))
+                    .limit(numRecommendations - recommendedProducts.size())
+                    .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
+            recommendedProducts.addAll(otherProducts);
+        }
+
+        return recommendedProducts;
+    }
+
+    private String getMostCommonCategory(List<String> categories) {
+        return categories.stream()
+                .collect(java.util.stream.Collectors.groupingBy(c -> c, java.util.stream.Collectors.counting()))
+                .entrySet().stream()
+                .max(Map.Entry.comparingByValue())
+                .map(Map.Entry::getKey)
+                .orElse(null);
+    }
+}
+
+// Helper classes (User, Product, Order, Payment) are omitted for brevity
+"""
+    st.code(java_monolithic_example, language="java")
+
+st.write("""
+In this example, all the main functionalities of the e-commerce application 
+(user management, product management, order processing, payment handling, and product recommendations) 
+are contained within a single application. They share the same data structures and are 
+tightly coupled.
+""")
+
+st.subheader("Interactive Exercise: Exploring the Monolithic Architecture")
+
+st.write("Let's modify the monolithic application to enhance the product recommendation system.")
+
+new_feature = st.text_area("Add a new method to the EcommerceApp class to implement a more advanced product recommendation system:", 
+                           height=200)
+
+if new_feature:
+    updated_code = monolithic_example.replace("def recommend_products(self, user, num_recommendations=3):", new_feature)
+    st.code(updated_code, language="python")
+    st.write("""
+    Now that you've enhanced the product recommendation system, consider the following:
+    1. How does this new feature interact with the existing components of the application?
+    2. What challenges might you face if you want to scale just the recommendation system?
+    3. How would you handle updates or maintenance for this feature in a monolithic architecture?
+    """)
+
+st.markdown("---")
+
+st.subheader("Quiz: Monolithic Architecture Concepts")
+monolithic_quiz()