DCT
6:23-cv-00306
S3G Technology LLC v. Claire's Stores Inc
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: Claire's Stores Inc. (Delaware)
- Plaintiff’s Counsel: PARKER, BUNT & AINSWORTH, P.C.
- Case Identification: 6:23-cv-00306, W.D. Tex., 04/26/2023
- Venue Allegations: Plaintiff alleges venue is proper because Defendant maintains a regular and established place of business in the district, specifically a retail store in Waco, Texas, and has transacted business and committed alleged infringing acts within the district.
- Core Dispute: Plaintiff alleges that Defendant’s mobile applications and associated backend systems infringe three patents related to the efficient, dynamic modification of software applications on remote devices.
- Technical Context: The technology addresses methods for updating client-server applications over a network by sending small, lightweight modules to modify application behavior, rather than transmitting a full, newly compiled version of the software.
- Key Procedural History: The complaint notes that the asserted patents are part of a portfolio that has been the subject of extensive prior litigation. It explicitly references claim construction rulings from a previous case, S3G Tech. LLC v. Unikey Techs., Inc., which construed key terms such as "code" and "dialogue module," suggesting these prior judicial interpretations will be central to the current dispute.
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Earliest Priority Date for '124, '571, and '774 Patents |
| 2013-07-11 | Notice of Allowability issued in related patent prosecution |
| 2013-10-29 | U.S. Patent No. 8,572,571 Issued |
| 2018-04-10 | U.S. Patent No. 9,940,124 Issued |
| 2019-04-16 | U.S. Patent No. 10,261,774 Issued |
| 2023-04-26 | Complaint Filed |
II. Technology and Patent(s)-in-Suit Analysis
U.S. Patent No. 9,940,124 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine," Issued April 10, 2018
The Invention Explained
- Problem Addressed: The patents address the difficulty and inefficiency of updating software applications distributed across numerous remote hardware devices, particularly over networks with limited bandwidth. Transmitting an entire newly compiled application to each device is described as time-consuming, costly, and sometimes technically infeasible. (Compl. ¶12-14; ’571 Patent, col. 2:1-52).
- The Patented Solution: The invention proposes a three-part system architecture—an update server, a service provider machine, and a terminal machine—that allows for targeted modification of applications. The applications themselves are structured with two distinct components: computer-executable instructions (like a runtime engine) and "code" (information that must be translated by the runtime). The update server sends small, lightweight "dialogue modules" containing new or updated "code" to the terminal and service provider machines. This modifies the application's behavior (e.g., changing a sequence of user prompts) without replacing the underlying executable instructions, thereby saving bandwidth and resources. (Compl. ¶15, ¶18; ’571 Patent, col. 4:21-25, FIG. 1). The complaint includes Figure 1 from the patent, a system diagram depicting communication between an update server machine (102), a service provider machine (110), and a terminal machine (120). (Compl. p. 7).
- Technical Importance: This architectural approach is presented as a way to improve computing and network resource utilization and to create design efficiencies when modifying applications on a large scale. (Compl. ¶9, ¶23).
Key Claims at a Glance
- The complaint asserts at least independent claim 1. (Compl. ¶28).
- The essential elements of independent method claim 1 include:
- Displaying a first prompt on a terminal machine by running a terminal application, which comprises first computer-executable instructions and first code.
- Accepting a first data entry at the terminal machine.
- Communicating information associated with the first data entry to a service provider machine, which uses a provider application comprising second computer-executable instructions and second code.
- Receiving, at the terminal machine, a terminal dialogue module that updates a portion of the first code to produce first updated code.
- The first updated code adapts the terminal application to display a second prompt for a modified dialogue sequence.
- The first code, second code, and first updated code comprise intermediate code.
- The complaint does not explicitly reserve the right to assert dependent claims.
U.S. Patent No. 8,572,571 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine," Issued October 29, 2013
The Invention Explained
- Problem Addressed: The '571 Patent shares a common specification with the ’124 Patent and addresses the same technical problem of inefficiently updating remotely distributed software. (Compl. ¶12; ’571 Patent, col. 2:1-52).
- The Patented Solution: The solution is the same three-entity architecture described for the ’124 Patent, where applications are comprised of separate executable instructions and translatable "code." The complaint includes Figure 2 from the patent, which illustrates this software structure, showing a terminal application (122) comprising first computer-executable instructions (224) and first code (222). (Compl. p. 7). This structure allows small "dialogue modules" to modify application behavior without full replacement. (Compl. ¶16-17; ’571 Patent, col. 7:40-45).
- Technical Importance: The technical importance is identical to that of the ’124 Patent: improving efficiency and reducing bandwidth consumption in distributed software systems. (Compl. ¶23).
Key Claims at a Glance
- The complaint asserts at least independent claim 2. (Compl. ¶42).
- The essential elements of independent system claim 2 include:
- An update server machine operable for sending a terminal dialogue module and a provider dialogue module.
- A terminal machine running a terminal application comprising a first set of computer-executable instructions and a first set of code, where the code is not directly executable.
- A service provider machine running a provider application comprising a second set of computer-executable instructions and a second set of code, where the code is not directly executable.
- The terminal dialogue module modifies the first set of code to produce first updated code, but does not modify the first set of computer-executable instructions.
- The provider dialogue module modifies the second set of code to produce second updated code, but does not modify the second set of computer-executable instructions.
- The complaint does not explicitly reserve the right to assert dependent claims.
Multi-Patent Capsule
- Patent Identification: U.S. Patent No. 10,261,774, "Modification of Terminal and Service Provider Machines Using an Update Server Machine," Issued April 16, 2019.
- Technology Synopsis: The '774 patent, which shares a common specification with the other asserted patents, is directed to a method for conducting a dialogue sequence between a terminal machine and a service provider machine. The method involves updating the terminal application's behavior by receiving "third code" that modifies the application's existing "first code" to produce an "updated code" for displaying a new prompt sequence, thereby avoiding a full application replacement. (’774 Patent, Abstract).
- Asserted Claims: At least independent claim 1 is asserted. (Compl. ¶55).
- Accused Features: The complaint alleges that the method of interaction between the Claire's mobile app and its backend servers—specifically where user interactions with a wish list prompt the server to send JSON data that updates the wish list displayed in the app—infringes the claimed method. (Compl. ¶56-60).
III. The Accused Instrumentality
Product Identification
- The accused instrumentalities are Defendant’s "Claire's mobile applications" for Android and iOS (the "Defendant app") and the associated backend "systems, methods, computing devices, including servers, software, and non-transitory computer readable storage medium that execute, run, store, support or facilitate the use of the Defendant app" (the "Accused System"). (Compl. ¶7).
Functionality and Market Context
- The complaint describes the Accused System as enabling users to perform various functions, with a specific focus on the ability to "review, edit and delete wish lists." (Compl. ¶30). In the alleged functionality, a user action on the mobile app prompts communication with the Defendant's server. The server then sends information, alleged to be in JSON format, back to the mobile app. This information is alleged to update the application's "code" to adapt its behavior, for example, by displaying a new or modified wish list to the user. (Compl. ¶30, ¶34). The complaint alleges that Defendant derives a "significant portion of its revenue" from the accused products and services. (Compl. ¶7).
IV. Analysis of Infringement Allegations
'124 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| displaying a first prompt on a terminal display of a terminal machine by running a terminal application, the terminal application comprising first computer-executable instructions and first code that conduct the terminal machine's portion of the dialogue sequence | The Claire's app (terminal application) on a user's smartphone (terminal machine) displays prompts related to a wish list. The app is alleged to comprise the Android Runtime (computer-executable instructions) and the app's bytecode (first code). | ¶30 | col. 16:50-56 |
| accepting a first data entry at the terminal machine, wherein the first data entry is associated with the first prompt | The user interacts with the wish list prompt, for example, by selecting an item to order. This is accepted as a data entry by the app. | ¶31 | col. 16:57-59 |
| communicating information associated with the first data entry from the terminal machine to the service provider machine, wherein the service provider machine uses a provider application comprising second computer-executable instructions and second code... | Information about the user's wish list selection is sent from the app to the Defendant's server (service provider machine). The server runs a .Net application alleged to comprise the Common Language Runtime (second computer-executable instructions) and .Net program code (second code). | ¶32 | col. 16:60-col. 17:2 |
| receiving, at the terminal machine, a terminal dialogue module... that updates at least a portion of the first code to produce first updated code, wherein the first updated code adapts the terminal application to display a second prompt for the terminal machine's portion of a modified dialogue sequence | The app receives a "terminal dialogue module" from the server, identified as the "terminal machine portion of a wish list" in JSON format. This JSON data allegedly updates the app's bytecode (first code) to produce updated code that allows the app to display a new prompt, such as accessing new wish lists. | ¶34 | col. 17:3-10 |
| wherein at least one of the first code, the second code, and the first updated code comprise intermediate code. | The app's bytecode is alleged to be intermediate code. | ¶34 | col. 18:14-16 |
'571 Patent Infringement Allegations
| Claim Element (from Independent Claim 2) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| an update server machine... operable for sending a terminal dialogue module... and a provider dialogue module... to allow the terminal machine and the service provider machine to conduct a dialogue sequence with each other | The complaint alleges the "update server machine" is either the user's device accessing the system or the Defendant's server itself. This machine sends a "terminal dialogue module" (e.g., wish list data in JSON format) to the user's device and a "provider dialogue module" (e.g., wish list portion) to the Defendant's server. Communication is alleged to be via HTTP. | ¶44 | col. 18:7-14 |
| ...the terminal machine... is configured to run a terminal application... comprising a first set of computer-executable instructions and a first set of code... wherein the first set of code is not able to execute directly on the terminal processor | The user's smartphone (terminal machine) runs the Claire's app (terminal application). The app is alleged to comprise the Android Runtime (first computer-executable instructions) and the app's bytecode (first code), which cannot be directly executed on the processor. | ¶45 | col. 18:15-23 |
| ...the service provider machine... is configured to run a provider application... comprising a second set of computer-executable instructions and a second set of code... wherein the second set of code is not able to execute directly on the provider processor | The Defendant's server (service provider machine) runs a .Net application (provider application). The application is alleged to comprise the Common Language Runtime (CLR) engine (second computer-executable instructions) and the .Net program's code (second code), which cannot be directly executed on the processor. | ¶46 | col. 18:24-34 |
| ...the terminal dialogue module modifies the first set of code to produce a first set of updated code... [and] does not modify the first set of computer-executable instructions | The wish list data (terminal dialogue module) received from the server allegedly modifies the app's bytecode (first code) to produce updated code for displaying a new wish list sequence. The complaint asserts this does not modify the Android Runtime (first computer-executable instructions). | ¶47, ¶22 | col. 18:35-42, 49-51 |
| ...the provider dialogue module modifies the second set of code to produce a second set of updated code... [and] does not modify the second set of computer-executable instructions | The portion of the wish list sent to the server (provider dialogue module) allegedly modifies the server's .Net program code (second code) to produce updated code for a modified dialogue. The complaint asserts this does not modify the CLR engine (second computer-executable instructions). | ¶47, ¶22 | col. 18:43-48, 52-54 |
Identified Points of Contention
- Scope Questions: A primary question relates to the mapping of the accused system to the claimed three-entity structure. The complaint alleges the "update server machine" could be either the user's mobile device or the Defendant's server (Compl. ¶44), raising a question of whether the accused client-server architecture actually contains the distinct three components required by the claims. Another question is whether the "terminal machine portion of a wish list" sent as a JSON object (Compl. ¶34) meets the structural requirements of a "terminal dialogue module."
- Technical Questions: A key technical question is whether the JSON data allegedly sent from the server to the Claire's app performs the function of "code" that "updates" the application's existing "code" as required by the claims. The analysis may turn on whether sending structured data that an application is designed to interpret is equivalent to sending "code" that "modifies" existing "code" in the manner contemplated by the patent, which distinguishes "code" from "computer-executable instructions." (Compl. ¶30, ¶45).
V. Key Claim Terms for Construction
The Term: "code"
Context and Importance: The infringement theory hinges on whether the JSON data exchanged between the Claire's app and its servers qualifies as "code." The complaint alleges that the app's bytecode is "code" and that the incoming JSON data "updates" this code. (Compl. ¶30, ¶34). Practitioners may focus on this term because if the JSON is determined to be mere data rather than the claimed "code," a central pillar of the infringement allegation could be undermined.
Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The complaint cites a prior court construction of "code" as "information that must be translated before it can be executed on a processor." (Compl. ¶16, n.5). Plaintiff may argue that JSON data is information that is "translated" or parsed by the application's runtime before affecting the display, fitting this construction. The patent specification's use of "Java Byte Code" as an example could be argued as illustrative, not limiting. (’571 Patent, col. 8:30-31).
- Evidence for a Narrower Interpretation: The patent consistently distinguishes between "computer-executable instructions" and "code." (’571 Patent, col. 7:40-45). A defendant may argue that this distinction implies "code" must be more instruction-like than a simple data-interchange format like JSON. The patent's entire premise is framed as an alternative to recompiling "source code," which may support an interpretation that "code" is closer to a compiled or intermediate instruction set than to structured data. (’571 Patent, col. 2:25-30).
The Term: "dialogue module"
Context and Importance: The complaint alleges that a "terminal machine portion of a wish list," sent as JSON, constitutes a "terminal dialogue module." (Compl. ¶34). The definition of this term is critical to determining whether the data packets in the accused system embody the specific structures claimed.
Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The specification states that a dialogue module "may include portions of code and/or instructions." (’571 Patent, col. 5:64-65). In a related litigation, the specification was also noted to disclose that a "dialogue module" can "contain code or other data." (Compl. ¶20). This could support an argument that a JSON object containing data qualifies.
- Evidence for a Narrower Interpretation: The complaint itself cites a court ruling stating that the patent "uses the term 'module' to refer to a particular type of structure rather than to any structure for performing a function." (Compl. ¶20, Exhibit D at 12). A defendant may argue that a JSON object is simply data for a pre-existing function (displaying a wish list) rather than the specific, self-contained "structure" required by the claims and highlighted by the court.
VI. Other Allegations
- Indirect Infringement: The complaint alleges induced infringement, stating that Defendant markets and promotes the accused apps with the knowledge and intent that customers' use will infringe the patents. (Compl. ¶35, ¶48, ¶61). It also alleges contributory infringement, asserting that the accused instrumentalities are not staple articles of commerce and are especially adapted for infringement. (Compl. ¶36, ¶49, ¶62).
- Willful Infringement: Willfulness allegations are based on Defendant having "actual knowledge" of the patents "at least since the filing of this complaint." (Compl. ¶27, ¶41, ¶54). The complaint does not allege pre-suit knowledge.
VII. Analyst’s Conclusion: Key Questions for the Case
- A central issue will be one of definitional scope: can the term "code", which the patent distinguishes from directly executable instructions, be construed to cover the JSON data files exchanged between the accused mobile app and its server, or is there a fundamental mismatch between a data format and the claimed "code that must be translated"?
- A key evidentiary question will be one of architectural mapping: does the accused client-server system embody the distinct three-part "terminal machine", "service provider machine", and "update server machine" structure required by the system claims, particularly given the complaint's ambiguous and alternative allegations for what constitutes the "update server machine"?
- A third question concerns functionality: does the accused system's process of receiving and displaying wish list data in the app constitute "modifying" the app's "code" to create "updated code" as claimed, or is it merely the ordinary operation of an application processing data it was designed to receive?