swarajya_2019-03_02df8f1d-1b92-4865-ac81-b73cad6f6133_ESPNCricinfo.webp

Cricinfo

Cricinfo is a sports news website exclusively for the game of cricket. The site features live coverage of cricket matches containing ball-by-ball commentary and a database for all the historic matches. The site also provides news and articles about cricket.

Features

We will focus on the following set of requirements while designing Cricinfo:

The system should keep track of all cricket-playing teams and their matches.
The system should show live ball-by-ball commentary of cricket matches.
All international cricket rules should be followed.
Any team playing a tournament will announce a squad (a set of players) for the tournament.
For each match, both teams will announce their playing-eleven from the tournament squad.
The system should be able to record stats about players, matches, and tournaments.
The system should be able to answer global stats queries like, “Who is the highest wicket taker of all time?”, “Who has scored maximum numbers of 100s in test matches?”, etc.
The system should keep track of all ODI, Test and T20 matches.

Rough Solution (LLD-Machine Coding)

// Enums representing various states and types in the cricket management system

public enum MatchFormat {
    ODI, T20, TEST
}

public enum MatchResult {
    LIVE, FINISHED, DRAWN, CANCELED
}

public enum UmpireType {
    FIELD, RESERVED, TV
}

public enum WicketType {
    BOLD, CAUGHT, STUMPED, RUN_OUT, LBW, RETIRED_HURT, HIT_WICKET, OBSTRUCTING
}

public enum BallType {
    NORMAL, WIDE, WICKET, NO_BALL
}

public enum RunType {
    NORMAL, FOUR, SIX, LEG_BYE, BYE, NO_BALL, OVERTHROW
}

// Supporting Address class
public class Address {
    private String streetAddress;
    private String city;
    private String state;
    private String zipCode;
    private String country;

    // Constructor, Getters, and Setters are omitted for brevity
}

// Abstract Person class
public abstract class Person {
    private String name;
    private Address address;
    private String email;
    private String phone;

    // Constructor, Getters, and Setters are omitted for brevity
}

// Player class representing a cricket player
public class Player extends Person {
    private List<PlayerContract> contracts = new ArrayList<>();

    public boolean addContract(PlayerContract contract) {
        contracts.add(contract);
        return true;
    }
}

// Admin class handling administrative tasks
public class Admin extends Person {
    public boolean addMatch(Match match) {
        System.out.println("Match added: " + match);
        return true;
    }

    public boolean addTeam(Team team) {
        System.out.println("Team added: " + team.getName());
        return true;
    }

    public boolean addTournament(Tournament tournament) {
        System.out.println("Tournament added: " + tournament.getName());
        return true;
    }
}

// Umpire class managing umpiring tasks
public class Umpire extends Person {
    public boolean assignMatch(Match match) {
        System.out.println("Umpire assigned to match: " + match.getMatchNumber());
        return true;
    }
}

// Referee class handling refereeing tasks
public class Referee extends Person {
    public boolean assignMatch(Match match) {
        System.out.println("Referee assigned to match: " + match.getMatchNumber());
        return true;
    }
}

// Commentator class handling match commentary, with Observer pattern
public class Commentator extends Person implements Observer {
    private List<Match> assignedMatches = new ArrayList<>();

    public boolean assignMatch(Match match) {
        assignedMatches.add(match);
        match.addObserver(this);
        System.out.println("Commentator assigned to match: " + match.getMatchNumber());
        return true;
    }

    @Override
    public void update(String commentaryText) {
        System.out.println("Commentator received update: " + commentaryText);
    }
}

// Observer interface for notifying Commentators about match updates
interface Observer {
    void update(String message);
}

// Observable Match class implementing match updates and observer management
public abstract class Match {
    private int number;
    private Date startTime;
    private MatchResult result;
    private List<Observer> observers = new ArrayList<>();

    private Playing11[] teams = new Playing11[2];
    private List<Inning> innings = new ArrayList<>();
    private List<Umpire> umpires = new ArrayList<>();
    private Referee referee;
    private List<Commentator> commentators = new ArrayList<>();
    private Stadium stadium;

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }

    public void assignStadium(Stadium stadium) {
        this.stadium = stadium;
    }

    public void assignReferee(Referee referee) {
        this.referee = referee;
    }

    public int getMatchNumber() {
        return number;
    }

    public void addCommentary(String commentaryText) {
        notifyObservers(commentaryText);
    }

    // Other match-specific methods omitted for brevity
}

// Specific match types using the Factory Pattern
public class ODI extends Match {
    // ODI-specific methods
}

public class Test extends Match {
    // Test-specific methods
}

public class T20 extends Match {
    // T20-specific methods
}

// Factory to create different match formats
public class MatchFactory {
    public static Match createMatch(MatchFormat format) {
        switch (format) {
            case ODI:
                return new ODI();
            case T20:
                return new T20();
            case TEST:
                return new Test();
            default:
                throw new IllegalArgumentException("Unknown format");
        }
    }
}

// Team class representing a cricket team
public class Team {
    private String name;
    private List<Player> players = new ArrayList<>();
    private Coach coach;

    public boolean addPlayer(Player player) {
        players.add(player);
        return true;
    }

    public boolean addNews(News news) {
        System.out.println("News added to team: " + name);
        return true;
    }

    public String getName() {
        return name;
    }
}

// Tournament-related classes
public class Tournament {
    private String name;
    private List<Team> teams = new ArrayList<>();

    public String getName() {
        return name;
    }
}

public class TournamentSquad {
    private List<Player> players = new ArrayList<>();

    public boolean addPlayer(Player player) {
        players.add(player);
        return true;
    }
}

// Playing11 class representing the final playing squad for a match
public class Playing11 {
    private List<Player> players = new ArrayList<>();
    private Player twelfthMan;

    public boolean addPlayer(Player player) {
        players.add(player);
        return true;
    }
}

// Ball-by-ball representation
public class Ball {
    private Player bowledBy;
    private Player playedBy;
    private BallType type;
    private Wicket wicket;
    private List<Run> runs = new ArrayList<>();
    private Commentary commentary;

    public void addRun(Run run) {
        runs.add(run);
    }

    public void addWicket(Wicket wicket) {
        this.wicket = wicket;
    }
}

// Over class representing an over in the match
public class Over {
    private int number;
    private List<Ball> balls = new ArrayList<>();

    public void addBall(Ball ball) {
        balls.add(ball);
    }
}

// Inning class representing an inning in the match
public class Inning {
    private int number;
    private Date startTime;
    private List<Over> overs = new ArrayList<>();

    public boolean addOver(Over over) {
        overs.add(over);
        return true;
    }
}

// Wicket class representing a wicket event
public class Wicket {
    private WicketType type;
    private Player playerOut;
    private Player caughtBy;
    private Player runoutBy;
    private Player stumpedBy;
}

// Commentary class for ball-by-ball commentary
public class Commentary {
    private String text;
    private Date createdAt;
    private Commentator createdBy;

    public Commentary(String text, Commentator createdBy) {
        this.text = text;
        this.createdBy = createdBy;
        this.createdAt = new Date();
    }
}

// Stadium class for the match location
public class Stadium {
    private String name;
    private Address location;

    public String getName() {
        return name;
    }
}

// Run class representing runs scored in a ball
public class Run {
    private RunType type;
    private int value;

    public Run(RunType type, int value) {
        this.type = type;
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

// Main class to demonstrate the use of the system
public class Main {
    public static void main(String[] args) {
        Admin admin = new Admin();
        Match match = MatchFactory.createMatch(MatchFormat.T20);
        admin.addMatch(match);

        Commentator commentator = new Commentator();
        commentator.assignMatch(match);

        match.addCommentary("Batsman hits a four!");
    }
}

Issues in Above Design

1️⃣ Match Is Doing Too Much (God Object Smell)

Problem

abstract class Match {
    Playing11[] teams;
    List<Inning> innings;
    List<Observer> observers;
    List<Commentator> commentators;
    Stadium stadium;
}

LLD Issues

Match handles:
- team composition
- live commentary
- observers
- innings
- umpires
- stadium
Violates Single Responsibility Principle

Impact

Any change in scoring / commentary / streaming affects Match
Hard to test or scale components independently

Interview Signal

Match should coordinate, not own everything.

Solution

will be covered in our premium course.

2️⃣ Live Commentary Is Synchronous (Concurrency Killer)

Problem

public void notifyObservers(String message) {
    for (Observer observer : observers) {
        observer.update(message);
    }
}

Concurrency Issue

Commentary updates happen in the match thread
If one observer is slow (DB write, network delay):
- whole match update blocks

Real Scenario

Ball delivered → commentary → DB lag → live feed freezes

Missing

Async dispatch
Event queue
Backpressure handling

Solution

will be covered in our premium course.

3️⃣ `ArrayList` Everywhere = Unsafe for Live Matches

Examples

List<Observer> observers
List<Over> overs
List<Ball> balls
List<Commentator> commentators

Concurrency Issue

Live matches update balls while:
- users read commentary
- stats engine reads data
Leads to:
- ConcurrentModificationException
- Partial reads
- Corrupt state

Interview Expectation

Live systems require immutable snapshots or concurrent collections.

Solution

will be covered in our premium course.

4️⃣ No Clear Match State Machine

Problem

MatchResult { LIVE, FINISHED, DRAWN, CANCELED }

LLD Issue

Result ≠ State
Missing states:
- SCHEDULED
- TOSS_DONE
- IN_PROGRESS
- IN_BREAK
- STUMPS

Impact

Illegal operations possible:
- add ball after match finished
- add commentary before start

Solution

will be covered in our premium course.

5️⃣ Ball-by-Ball Updates Are Not Atomic

Problem

Ball {
    Run runs;
    Wicket wicket;
    Commentary commentary;
}

Concurrency Issue

Ball creation involves multiple steps:
1. add run
2. add wicket
3. add commentary
Readers may see:
- run without wicket
- commentary without run

Impact

Incorrect scorecards
Wrong stats aggregation

Interview Keyword

Atomic event publication

Solution

will be covered in our premium course.

6️⃣ Stats Queries Will Kill the System

Requirement

“Highest wicket taker of all time?”

Current Gap

No stats aggregation model
No pre-computation
No read-optimized structures

Concurrency + LLD Issue

Live match updates + historical queries
If both hit same data store:
- lock contention
- slow queries

Correct Direction

Write model ≠ Read model (CQRS idea)
Incremental stats updater

Solution

will be covered in our premium course.

7️⃣ Observer Pattern Misused (Tight Coupling)

Problem

class Commentator implements Observer

LLD Issue

Commentator tightly coupled to match
Observer receives raw strings instead of events

Impact

Can’t reuse observer for:
- push notifications
- WebSocket feeds
- mobile apps

Better Model

MatchEvent → EventBus → Consumers

Solution

will be covered in our premium course.

8️⃣ Tournament & Squad Integrity Not Enforced

Problem

Playing11 {
    List<Player> players;
}

LLD Issue

No validation:
- 11 players only
- must be from tournament squad
- role constraints (wicketkeeper, etc.)

Impact

Invalid matches possible
Rules enforcement missing

Solution

will be covered in our premium course.

9️⃣ No Time Ordering Guarantees (Critical for Live)

Problem

Overs, balls, commentary stored in lists
No sequence IDs or versioning

Concurrency Issue

Two threads:
- Thread A adds ball
- Thread B adds commentary
Ordering breaks

Result

Commentary: "OUT!"
Ball: added later

Interview Keyword

Event ordering & versioning

Solution

will be covered in our premium course.

🔟 Admin Operations Are Not Transactional

Problem

admin.addMatch(match);
admin.addTournament(tournament);

LLD + Concurrency Issue

No transactional boundaries
Partial failure leads to:
- match without tournament
- teams without squads

Solution

will be covered in our premium course.

Cricinfo

Features

Rough Solution (LLD-Machine Coding)

Issues in Above Design

1️⃣ Match Is Doing Too Much (God Object Smell)

Problem

LLD Issues

Impact

Interview Signal

Solution

2️⃣ Live Commentary Is Synchronous (Concurrency Killer)

Problem

Concurrency Issue

Real Scenario

Missing

Solution

3️⃣ ArrayList Everywhere = Unsafe for Live Matches

Examples

Concurrency Issue

Interview Expectation

Solution

4️⃣ No Clear Match State Machine

Problem

LLD Issue

Impact

Solution

5️⃣ Ball-by-Ball Updates Are Not Atomic

Problem

Concurrency Issue

Impact

Interview Keyword

Solution

6️⃣ Stats Queries Will Kill the System

Requirement

Current Gap

Concurrency + LLD Issue

Correct Direction

Solution

7️⃣ Observer Pattern Misused (Tight Coupling)

Problem

LLD Issue

Impact

Better Model

Solution

8️⃣ Tournament & Squad Integrity Not Enforced

Problem

LLD Issue

Impact

Solution

9️⃣ No Time Ordering Guarantees (Critical for Live)

Problem

Concurrency Issue

Result

Interview Keyword

Solution

🔟 Admin Operations Are Not Transactional

Problem

LLD + Concurrency Issue

Solution

3️⃣ `ArrayList` Everywhere = Unsafe for Live Matches

Design (LLD) Cricinfo - Machine Coding