Protocol Design Improvements

Communication Protocol Encapsulation

• Replace current dictionary-based message handling with proper class-based representations for better type safety, code decoupling and organization
• Define explicit field types and validation for each message type represented as classes
• Implement dedicated marshaling/unmarshaling class methods for both wire protocol and JSON formats
• Create a unified interface for protocol handling to reduce code duplication

Wire Protocol Optimization

• Introduce message correlation IDs to properly match requests with responses
• Move away from implicit request-response assumptions that don't scale well
• Include state information in protocol messages for more robust handling
• Consider adopting a simpler text-based command protocol inspired by other implementations

Inspiration From Demo Day

During the in-class demonstrations, we observed an simple and elegant solution from another team who implemented a text-based command-line-like interface. Their user interface is simple: users interact by only sending texts. Their approach highlighted several potential improvements for our system:

• Simplified Wire Protocol Design: Instead of dealing with complex object serialization, commands could follow a simple format, and we only need to send a string on the socket:

COMMAND [arg1] [arg2] ...

• Centralized Processing: The client's role would be streamlined to:
  1. Send raw text commands to the server
  2. Receive formatted text responses
  3. Display results directly to the user
• Reduced Complexity: This approach would eliminate several pain points we encountered:
  • No need for complex nested object serialization
  • Simplified error handling through text-based responses
  • Easier debugging as commands are human-readable
  • More straightforward client-GUI integration

Example command structure:

# Current complex protocol
{"type": "send_message", "data": {"recipient": "user1", "content": "Hello", "timestamp": 1234567}}

# Simplified text-based alternative
SEND user1 Hello

This design pattern would maintain functionality while significantly reducing implementation complexity and improving maintainability.