UNIT 3: Intelligent Systems and Web Technologies for E-Commerce

A. Artificial Intelligence Fundamentals

1. Problem Solving and Search Algorithms

Uninformed Search

Searches without domain-specific knowledge.

Where $b$ = branching factor, $d$ = solution depth, $m$ = maximum depth.

[!TIP] Exam Focus: BFS is complete and optimal for uniform-cost trees but memory-intensive. DFS is memory-efficient but not complete/optimal. Compare them directly in 7-mark questions.

Informed Search (Heuristic Search)

Uses heuristic function $h(n)$ to guide search.

A Algorithm:*

• Evaluates nodes using $$\displaystyle f(n) = g(n) + h(n) $$.

  • $g(n)$: Actual cost from start to node $n$.

  • $h(n)$: Estimated cost from $n$ to goal (admissible & consistent heuristic).

• Optimal & Complete if $h(n)$ is admissible (never overestimates true cost).

• Uses a priority queue (min-heap) ordered by $f(n)$.

[!TIP] 8-Puzzle Problem: For given initial/final states, calculate $g(n)$ (depth) and $h(n)$ (misplaced tiles) for each node, expand node with lowest $f(n)$.

Heuristic Example: Manhattan Distance

• For grid-based problems (like mouse in maze).

• $$\displaystyle h(n) = |x_{current} - x_{goal}| + |y_{current} - y_{goal}| $$.

• Sum of horizontal & vertical distances, ignoring obstacles.

Local Search

• Used for optimization problems where path to goal is irrelevant.

• Hill Climbing: Greedy algorithm; moves to neighbor with best heuristic value.

• Problems in Hill Climbing:

  1. Local Maxima: Peak higher than neighbors but not global max.

  2. Plateau: Flat area where all neighbors have same value.

  3. Ridge: Sequence of local maxima; hard to navigate.

  4. Local Minima: (for minimization) Valley not global min.

2. Production Systems

Production Rule: IF <condition> THEN <action>.

• Characteristics:

  • Modular: Rules independent, easy to add/remove.

  • Incremental: Rules can be added without restructuring.

  • Uniform: All rules use same syntax.

  • Declarative: Knowledge (condition) separate from control (action).

Water Jug Problem (4-gallon & 3-gallon jugs, target: 2 gallons in 4-gallon jug):

Operators (Rules):

1. Fill 4G jug: $$\displaystyle (x, y) \rightarrow (4, y) $$

2. Fill 3G jug: $$\displaystyle (x, y) \rightarrow (x, 3) $$

3. Empty 4G jug: $$\displaystyle (x, y) \rightarrow (0, y) $$

4. Empty 3G jug: $$\displaystyle (x, y) \rightarrow (x, 0) $$

5. Pour 4G → 3G until 3G full or 4G empty.

6. Pour 3G → 4G until 4G full or 3G empty.

One Solution Path:

(0,0) → Fill 4G → (4,0)

→ Pour 4G→3G → (1,3)

→ Empty 3G → (1,0)

→ Pour 4G→3G → (0,1)

→ Fill 4G → (4,1)

→ Pour 4G→3G → (2,3) → **Goal: (2,3)**

3. Knowledge Representation

Properties of Good KR System:

1. Representational Adequacy: Express required knowledge.

2. Inferential Adequacy: Derive new knowledge efficiently.

3. Inferential Efficiency: Guide inference process.

4. Acquisitional Efficiency: Acquire new knowledge easily.

Representation Techniques:

4. Reasoning Methods

Monotonic vs Non-Monotonic Reasoning:

• Monotonic: Adding knowledge never retracts conclusions. Classical logic.

  • Example: Socrates is a man, All men are mortal → Socrates is mortal. Always true.

• Non-Monotonic: Adding knowledge can retract conclusions. Handles incomplete/uncertain info.

  • Example: Bird(X) typically implies Flies(X). But Penguin(Tweety) → retract Flies(Tweety).

5. Fuzzy Logic

Fuzzy Set: $$\displaystyle A = \mu_A(x_1)/x_1 + \mu_A(x_2)/x_2 + ... $$

where $$\displaystyle \mu_A(x_i) \in [0,1] $$ is membership degree.

Operations on Fuzzy Sets A & B:

6. Game Playing

Min-Max Algorithm:

• Used in two-player, zero-sum games (e.g., chess, tic-tac-toe).

• Max player aims to maximize score; Min player minimizes.

• Search tree: nodes = game states, edges = moves.

• Procedure:

  1. Generate game tree to a fixed depth (or terminal state).

  2. Assign utility values to terminal nodes (win=+1, loss=-1, draw=0).

  3. Back up values:

     • Max node: value = $\max$(child values).

     • Min node: value = $\min$(child values).

  4. At root, choose move leading to child with highest min-max value.

[!TIP] Alpha-Beta Pruning: Optimizes Min-Max by pruning branches that won't affect final decision.

7. Machine Learning

Neural Networks:

• Computing systems inspired by biological neurons.

• Structure: Input layer → Hidden layer(s) → Output layer.

• Each connection has weight; neurons apply activation function.

Types of Learning:

1. Supervised: Labeled data; learn mapping input→output.

   • Example: Classification (spam filter), Regression (price prediction).

2. Unsupervised: Unlabeled data; find hidden patterns.

   • Example: Clustering (customer segmentation), Dimensionality reduction.

3. Reinforcement: Agent learns via rewards/penalties from environment.

   • Example: Game playing (AlphaGo), Robotics.

4. Semi-supervised: Mix of labeled & unlabeled data.

5. Self-supervised: Generate labels from data itself (e.g., predicting image rotation).

8. Natural Language Processing (NLP)

Components of Natural Language Understanding:

1. Morphological Analysis: Break words into base forms (lemmatization/stemming).

2. Syntactic Analysis (Parsing): Analyze sentence structure (grammar).

3. Semantic Analysis: Extract meaning; resolve word sense ambiguity.

4. Pragmatic Analysis: Interpret meaning in context (speaker intent, sarcasm).

5. Discourse Analysis: Understand relationships between sentences.

9. Expert Systems

Definition: AI program that mimics human expert's decision-making in a specific domain.

• Components:

  • Knowledge Base: Facts & rules (IF-THEN) about domain.

  • Inference Engine: Applies rules to derive conclusions (forward/backward chaining).

  • User Interface: Interacts with user.

  • Explanation Facility: Explains reasoning (why/how).

  • Knowledge Acquisition: Tools to add knowledge.

• Example: MYCIN (medical diagnosis), DENDRAL (chemical analysis).

10. Probabilistic Reasoning

Bayes' Theorem:

$$P(A|B) = \frac{P(B|A) \cdot P(A)}{P(B)}$$

• $P(A|B)$: Posterior probability of A given B.

• $P(B|A)$: Likelihood.

• $P(A)$: Prior probability.

• $P(B)$: Marginal likelihood (normalizing constant).

Application: Naive Bayes classifier for spam detection.

Resolution Technique (Propositional Logic):

• Rule inference for proving theorems.

• Steps:

  1. Convert all statements to Conjunctive Normal Form (CNF): AND of ORs.

  2. To prove goal $G$, assume $\neg G$ and add to knowledge base.

  3. Repeatedly resolve pairs of clauses containing complementary literals.

  4. If empty clause □ derived → contradiction → $G$ is true.

• Example:

  • KB: $A \lor B$, $\neg B$, $$\displaystyle A \rightarrow C $$

  • Goal: $C$

  • Convert: $A \lor B$, $\neg B$, $\neg A \lor C$

  • Resolve $A \lor B$ & $\neg B$ → $A$

  • Resolve $A$ & $\neg A \lor C$ → $C$ ✓

B. Java Programming for E-Commerce Applications

1. Java Fundamentals

Iteration Statements (Loops):

// for loop

for(int i=0; i<5; i++) { System.out.println(i); }

// while loop

int i=0;

while(i<5) { System.out.println(i); i++; }

// do-while (executes at least once)

int i=0;

do { System.out.println(i); i++; } while(i<5);

Jump Statements:

• break: Exit loop/switch immediately.

• continue: Skip current iteration, proceed to next.

• return: Exit method, optionally return value.

Constructors:

• Special method called on object creation; same name as class.

• Types:

  1. Default: No parameters; sets default values.

  2. Parameterized: Accepts arguments to initialize fields.

  3. Copy Constructor: Takes object of same class, copies values.

Example: Area of Circle using Constructor

class Circle {

    double radius;

    Circle(double r) { radius = r; } // Parameterized constructor

    double area() { return Math.PI * radius * radius; }

}

Keywords:

• static: Belongs to class, not instance. One copy shared.

  
  static int count; // Class variable
  
  static void method() {} // Class method
  
  

• `final:** Variable (constant), method (cannot override), class (cannot inherit).

  
  final double PI = 3.14; // Constant
  
  final void show() {} // Cannot override
  
  

2. Object-Oriented Programming in Java

Polymorphism:

• Method Overloading: Same method name, different parameters (compile-time).

  
  void add(int a, int b) { ... }
  
  void add(double a, double b) { ... }
  
  

• Method Overriding: Subclass redefines superclass method (runtime).

  
  class Animal { void sound() { System.out.println("Animal sound"); } }
  
  class Dog extends Animal { void sound() { System.out.println("Bark"); } } // Override
  
  

• Dynamic Method Dispatch: Runtime resolution of overridden method.

  
  Animal a = new Dog();
  
  a.sound(); // Calls Dog's sound() (runtime binding)
  
  

Abstraction:

• Abstract Class: Cannot instantiate; may have abstract methods (no body).

  
  abstract class Shape {
  
      abstract double area(); // Abstract method
  
      void display() { System.out.println("Shape"); } // Concrete method
  
  }
  
  class Circle extends Shape {
  
      double area() { return Math.PI*r*r; } // Must implement
  
  }
  
  

• Interface: Pure abstraction; all methods abstract (pre-Java 8), now can have default/static methods.

  
  interface Drawable {
  
      void draw(); // Implicitly public abstract
  
  }
  
  class Rectangle implements Drawable {
  
      public void draw() { ... } // Must implement all
  
  }
  
  

3. Graphical User Interface (Swing)

Simple Swing App: Sum of Two Numbers

import javax.swing.*;

import java.awt.event.*;

public class SumApp {

    public static void main(String[] args) {

        JFrame frame = new JFrame("Sum Calculator");

        JTextField t1 = new JTextField(10);

        JTextField t2 = new JTextField(10);

        JButton btn = new JButton("Add");

        JLabel result = new JLabel("Result: ");

        btn.addActionListener(e -> {

            int a = Integer.parseInt(t1.getText());

            int b = Integer.parseInt(t2.getText());

            result.setText("Result: " + (a+b));

        });

        JPanel panel = new JPanel();

        panel.add(t1); panel.add(t2); panel.add(btn); panel.add(result);

        frame.add(panel);

        frame.setSize(300,100);

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        frame.setVisible(true);

    }

}

4. Applets

Applet Life Cycle:

1. init(): Called once when applet first loads. Initialize resources.

2. start(): Called after init(), also when applet becomes active (e.g., browser tab selected).

3. stop(): Called when applet is inactive (e.g., browser tab hidden).

4. destroy(): Called once before applet is unloaded. Cleanup resources.

5. paint(Graphics g): Called to render UI (also on resize/refresh).

[!TIP] Modern Java deprecates Applets; use Java Web Start or other technologies.

5. Memory Management

Garbage Collection (GC):

• Automatic memory management; reclaims memory from unused objects.

• How it works:

  1. JVM identifies unreachable objects (no references).

  2. GC thread (daemon) runs periodically.

  3. Common algorithms: Mark-and-Sweep, Generational (Young/Old Gen).

• System.gc(): Suggestion to run GC; not guaranteed.

• Finalize(): Deprecated; called before object is collected (unreliable).

6. Multithreading

Thread Creation:

1. Extend Thread class:

   
   class MyThread extends Thread {
   
       public void run() { System.out.println("Thread running"); }
   
   }
   
   new MyThread().start();
   
   

2. Implement Runnable interface (preferred):

   
   class MyRunnable implements Runnable {
   
       public void run() { ... }
   
   }
   
   new Thread(new MyRunnable()).start();
   
   

Thread Synchronization:

• Prevent race conditions when multiple threads access shared resource.

• Use synchronized keyword:

  
  synchronized void method() { ... } // Method-level
  
  synchronized(obj) { ... } // Block-level
  
  

Inter-Thread Communication:

• wait(), notify(), notifyAll() (must be called within synchronized context).

• Example: Producer-Consumer problem.

Example: Three Threads with Different Delays

class MyThread extends Thread {

    String msg; int interval;

    MyThread(String m, int i) { msg=m; interval=i; }

    public void run() {

        while(true) {

            System.out.println(msg);

            try { Thread.sleep(interval*1000); } catch(InterruptedException e){}

        }

    }

}
// In main:

new MyThread("Hello!", 1).start();

new MyThread("Wear Mask!", 2).start();

new MyThread("Use Sanitizer!", 5).start();

7. JavaBeans

Introspection: Ability to discover properties, events, methods of a bean at runtime.

• BeanInfo Interface: Provides explicit bean information.

  
  public class MyBeanInfo extends SimpleBeanInfo {
  
      public PropertyDescriptor[] getPropertyDescriptors() {
  
          PropertyDescriptor pd = new PropertyDescriptor("propertyName", MyBean.class);
  
          return new PropertyDescriptor[]{pd};
  
      }
  
  }
  
  

• Tools (e.g., IDE builders) use introspection to manipulate beans visually.

8. JNDI (Java Naming and Directory Interface)

Key Methods (Context interface):

9. Exception Handling

Mechanisms:

• try: Block containing code that may throw exception.

• catch: Handles specific exception type.

• throw: Explicitly throw an exception.

• throws: Declare exceptions that method may throw (compile-time checking).

• Assertions: assert condition; or assert condition : message;; enabled with -ea flag.

Example:

try {

    int result = 10 / 0; // ArithmeticException

    throw new IOException("File error"); // Explicit throw

} catch (ArithmeticException e) {

    System.out.println("Divide by zero: " + e.getMessage());

} catch (IOException e) {

    System.out.println(e);

} finally {

    System.out.println("Always executes"); // Cleanup

}

10. Database Connectivity (JDBC)

Steps to Connect & Query:

1. Load Driver: Class.forName("com.mysql.cj.jdbc.Driver");

2. Establish Connection: Connection conn = DriverManager.getConnection(url, user, pass);

3. Create Statement: Statement stmt = conn.createStatement();

4. Execute Query: ResultSet rs = stmt.executeQuery("SELECT * FROM table");

5. Process Result: while(rs.next()) { rs.getInt("id"); }

6. Close Resources: rs.close(); stmt.close(); conn.close(); (Use try-with-resources in Java 7+).

JDBC-ODBC Bridge: (Legacy, removed in Java 8)

• sun.jdbc.odbc.JdbcOdbcDriver allowed JDBC to access ODBC data sources.

• Replaced by pure Java JDBC drivers.

11. I/O Streams

Copy File using Character Streams:

try (BufferedReader br = new BufferedReader(new FileReader("source.txt"));

     BufferedWriter bw = new BufferedWriter(new FileWriter("dest.txt"))) {

    String line;

    while ((line = br.readLine()) != null) {

        bw.write(line);

        bw.newLine();

    }

}

12. Packages

Create Package:

// File: com/mypackage/MyClass.java

package com.mypackage;

public class MyClass { ... }

Compile: javac -d . MyClass.java (creates directory structure).

Access Protection Levels:

13. Event Handling

Event Sources: Objects that generate events (e.g., JButton, JTextField). Event Listeners: Interfaces that handle events (e.g., ActionListener, MouseListener).

Example: Button Click

JButton btn = new JButton("Click");

btn.addActionListener(new ActionListener() {

    public void actionPerformed(ActionEvent e) {

        System.out.println("Button clicked!");

    }

});

Java 8+ Lambda: btn.addActionListener(e -> System.out.println("Clicked"));

14. Networking

Client-Server Communication (TCP): Server:

ServerSocket ss = new ServerSocket(1234);

Socket s = ss.accept(); // Wait for client

BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));

PrintWriter out = new PrintWriter(s.getOutputStream(), true);

String msg = in.readLine();

out.println("Echo: " + msg);

s.close(); ss.close();

Client:

Socket s = new Socket("localhost", 1234);

PrintWriter out = new PrintWriter(s.getOutputStream(), true);

BufferedReader in = new BufferedReader(new InputStreamReader(s.getInputStream()));

out.println("Hello Server");

System.out.println(in.readLine());

s.close();

15. Multiple Inheritance in Java

Implemented via Interfaces:

• A class can implement multiple interfaces.

• Interfaces can have default methods (Java 8+); conflicts resolved by overriding.

Example:

interface A { default void show() { System.out.println("A"); } }

interface B { default void show() { System.out.println("B"); } }

class C implements A, B {

    public void show() { A.super.show(); } // Resolve conflict

}

[!TIP] Java does not support multiple class inheritance (to avoid diamond problem), but interfaces with default methods require explicit resolution.