DCT
2:23-cv-00265
S3G Technology LLC v. The Children's Place, Inc.
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: The Children's Place, Inc. (Delaware)
- Plaintiff’s Counsel: Parker, Bunt & Ainsworth, P.C.
- Case Identification: 2:23-cv-00265, E.D. Tex., 06/02/2023
- Venue Allegations: Plaintiff alleges venue is proper in the Eastern District of Texas because Defendant maintains a "regular and established place of business" in the district, distributes the accused mobile applications to customers in the district, and derives substantial revenue from business conducted therein.
- Core Dispute: Plaintiff alleges that Defendant’s mobile e-commerce application and associated backend systems infringe three patents related to methods for efficiently modifying software on remote devices using modular updates.
- Technical Context: The technology addresses the challenge of updating client-server applications, particularly on mobile devices, by using small "dialogue modules" to alter application behavior without requiring a full recompilation and reinstallation of the entire software package.
- Key Procedural History: The complaint heavily relies on claim construction rulings from prior litigation involving the same patents (S3G Tech. LLC v. Unikey Techs., Inc.), citing the court's interpretation of key terms like "code," "dialogue module," and the structural nature of the claimed machine entities. The complaint also cites the patent examiner's reasons for allowance to argue the novelty of the claimed system architecture.
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Earliest Priority Date for ’897, ’124, and ’774 Patents |
| 2013-07-11 | Notice of Allowability for '897 Patent Family |
| 2015-07-14 | ’897 Patent Issued |
| 2017-07-07 | Claim Construction Order in S3G v. Unikey |
| 2017-11-01 | Adoption of Claim Construction Rulings in S3G v. Unikey |
| 2018-04-10 | ’124 Patent Issued |
| 2019-04-16 | ’774 Patent Issued |
| 2023-05-22 | Accused Android App Last Updated |
| 2023-05-31 | Accused iOS App Last Updated |
| 2023-06-02 | Complaint Filed |
II. Technology and Patent(s)-in-Suit Analysis
U.S. Patent No. 9,081,897 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine," issued July 14, 2015
The Invention Explained
- Problem Addressed: The patent addresses the inefficiency and difficulty of updating software applications across a large number of geographically dispersed devices, particularly over wireless networks with limited bandwidth. Traditional methods requiring full recompilation and transmission of the entire application are described as slow, costly, and impractical. (’897 Patent, col. 2:4-55).
- The Patented Solution: The invention proposes a three-entity system architecture: an "update server machine," a "terminal machine" (e.g., a user device), and a "service provider machine" (e.g., a backend server) (’897 Patent, FIG. 1). Instead of sending a full new application, the update server sends small "dialogue modules" to the other machines. These modules contain "code" that modifies the behavior and user interface of the applications on the terminal and server, but crucially, do not modify the underlying "computer-executable instructions" of those applications. This allows for targeted, lightweight updates. (Compl. ¶¶15, 19; ’897 Patent, col. 7:55-67).
- Technical Importance: This architectural approach aims to improve network utilization and design efficiency, enabling rapid and flexible customization of remote software without the overhead of full application replacement. (Compl. ¶19; ’897 Patent, col. 6:51-53).
Key Claims at a Glance
- The complaint asserts at least independent claim 1. (Compl. ¶28). The complaint does not explicitly reserve the right to assert dependent claims but makes general allegations of infringement.
- Independent Claim 1 (a system claim) requires:
- An update server machine operable for sending a terminal dialogue module and a provider dialogue module.
- A terminal machine running a terminal application, which comprises a "first set of computer-executable instructions" and a "first set of code."
- A service provider machine running a provider application, which comprises a "second set of computer-executable instructions" and a "second set of code."
- The terminal dialogue module modifies the first set of code (but not the first set of computer-executable instructions) to produce updated code that adapts the terminal application.
- The provider dialogue module modifies the second set of code (but not the second set of computer-executable instructions) to produce updated code that adapts the provider application.
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: Similar to the ’897 patent, this patent addresses the problem of inefficient updates for distributed software systems. (’124 Patent, col. 2:15-67).
- The Patented Solution: This patent claims a method for conducting a dialogue. The method involves a terminal machine displaying a prompt from a terminal application (comprising first computer-executable instructions and first code), accepting data, and communicating it to a service provider. The key inventive step is the terminal machine receiving a "terminal dialogue module" that updates a portion of the "first code" to produce "first updated code." This updated code then adapts the application to display a second, different prompt as part of a modified dialogue. The patent specifies that the "code" involved is "intermediate code," such as Java bytecode. (’124 Patent, Abstract; col. 16:51-67).
- Technical Importance: By claiming the process of interaction and modification using "intermediate code," the patent protects the dynamic operation of the system, a common strategy to gain broader protection than a pure system claim. (Compl. ¶52).
Key Claims at a Glance
- The complaint asserts at least independent claim 1. (Compl. ¶46).
- Independent Claim 1 (a method claim) requires:
- Displaying a first prompt from a terminal application comprising "first computer-executable instructions" and "first code."
- Accepting a first data entry at the terminal machine.
- Communicating information associated with the data entry to a service provider machine.
- Storing at least a portion of the information in memory for analysis.
- Receiving a "terminal dialogue module" that updates the "first code" to produce "first updated code."
- The "first updated code" adapts the terminal application to display a second prompt.
- At least one of the "first code," "second code" (on the server), and "first updated code" must comprise "intermediate code."
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: Continuing the theme of its parent patents, the ’774 patent claims a method for conducting a dialogue sequence between a terminal and service provider machine. It focuses on the terminal machine receiving "third code" which modifies its existing "first code" to produce "first updated code," thereby adapting the terminal application to display a new prompt as part of a modified dialogue. This again protects the dynamic, partial update process central to the patent family's invention. (’774 Patent, Abstract; Compl. ¶¶12-15).
- Asserted Claims: The complaint asserts at least independent claim 1. (Compl. ¶65).
- Accused Features: The complaint alleges that the Defendant's mobile application and server system practice the claimed method, identifying user interactions with features like a "favorite item list" as the dialogue sequence and data sent from the server (e.g., JSON data) as the "third code" that modifies the application's behavior. (Compl. ¶¶66-70).
III. The Accused Instrumentality
Product Identification
- The "Accused System" comprises "The Children's Place" mobile applications for Android and iOS, along with the associated computing systems, servers, and software that support the apps. (Compl. ¶7).
Functionality and Market Context
- The Accused System is an e-commerce platform allowing users to browse and purchase products. The complaint focuses on the "favorite item (list)" feature as an exemplary infringing functionality. (Compl. ¶30). In this context, a user's smartphone is alleged to be the "terminal machine" running the app (the "terminal application"). The app communicates with Defendant's backend servers (the "service provider machine"). When a user's favorites list is modified, the complaint alleges that data is sent from the server to the app, which updates the user interface to reflect the change. This update process, which allegedly occurs without reinstalling the app, is the core of the infringement allegations. (Compl. ¶¶30-33).
IV. Analysis of Infringement Allegations
The complaint provides two key visual aids. A diagram from the patent, FIG. 1, illustrates the claimed three-entity architecture involving an update server, service provider machine, and terminal machine. (Compl. ¶15, p. 7). A second diagram, FIG. 2, illustrates the internal structure of the claimed applications, distinguishing between computer-executable instructions and modifiable "code." (Compl. ¶16, p. 8).
'897 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| one or more update server machines... operable for sending a terminal dialogue module... and a provider dialogue module... | The Accused System includes update server machines (e.g., a user's device accessing the website, or the Defendant's server) that send "dialogue modules" (e.g., "favorite item (list)" data) to the terminal and service provider machines. | ¶30 | col. 4:24-31 |
| a terminal machine... configured to run a terminal application... comprises a first set of computer-executable instructions and a first set of code... | The terminal machine is a user's smartphone running the Defendant's app. The "first set of computer-executable instructions" is the Android Runtime (ART), and the "first set of code" is the app's bytecode. | ¶31 | col. 7:45-50 |
| a service provider machine... configured to run a provider application... comprises a second set of computer-executable instructions and a second set of code... | The service provider machine is the Defendant's server running a .Net application. The "second set of computer-executable instructions" is the .Net Common Language Runtime (CLR), and the "second set of code" is the .Net program. | ¶32 | col. 7:35-44 |
| wherein the terminal dialogue module modifies the first set of code... [and] does not modify the first set of computer-executable instructions... | The "favorite item (list)" data modifies the app's bytecode to produce updated code for the user interface, but does not modify the underlying ART. | ¶33 | col. 8:50-58 |
| wherein the second set of updated code adapts the provider application to use the modified dialogue sequence with the terminal machine. | The updated code on the server adapts the server application to use the modified dialogue sequence (e.g., the updated favorites list) in its interactions with the user's app. | ¶33 | col. 4:24-31 |
'124 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| displaying a first prompt... by running a terminal application, the terminal application comprising first computer-executable instructions and first code... | The Defendant's app (comprising ART and bytecode) displays the user's "favorite item (list)." | ¶48 | col. 15:46-53 |
| accepting a first data entry at the terminal machine... | The user interacts with the list (e.g., selects a button to add, delete, or order an item). | ¶49 | col. 15:54-58 |
| communicating information associated with the first data entry from the terminal machine to the service provider machine... | Information about the user's action on the favorites list is sent from the app to the Defendant's server. | ¶50 | col. 15:59-67 |
| receiving, at the terminal machine, a terminal dialogue module that updates at least a portion of the first code to produce first updated code... | The app receives a "terminal dialogue module" (e.g., JSON data) from the server, which updates the app's bytecode (the "first code") to create "first updated code." | ¶52 | col. 16:6-10 |
| wherein the first updated code adapts the terminal application to display a second prompt... | The updated bytecode causes the app to display a new or modified view of the favorites list, which constitutes a "second prompt." | ¶52 | col. 16:11-16 |
| 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." | ¶52 | col. 7:48-50 |
- Identified Points of Contention:
- Scope Questions: The case may turn on whether routine data synchronization in a standard client-server application (e.g., updating a favorites list with JSON data) constitutes the specific, structured "dialogue sequence" modification via a "dialogue module" as claimed in the patents and construed in prior litigation. A central question is whether a data payload like a JSON object meets the structural definition of a "dialogue module."
- Technical Questions: A key technical question for the court will be whether the complaint's division of the accused software into "computer-executable instructions" (the runtime environment, e.g., ART/CLR) and "code" (the application bytecode) is a valid interpretation of the claim language as applied to the accused system, or if it is an artificial distinction created for litigation.
V. Key Claim Terms for Construction
The complaint relies on constructions from prior litigation, making the application of those constructions to the current facts the primary issue.
The Term: "code"
Context and Importance: This term is the lynchpin of the invention's alleged efficiency. The distinction between "code" (which is modified) and "computer-executable instructions" (which are not) must hold up. Infringement hinges on whether the accused app's bytecode can be properly classified as "code" that is separate from un-modified "computer-executable instructions" (the runtime). Practitioners may focus on this term because the plaintiff's infringement theory depends entirely on this specific architectural separation.
Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The specification states that "code" can be "intermediate code (e.g., Java Byte Code)," suggesting it covers formats that are not directly machine-executable but are interpreted or just-in-time compiled. (’897 Patent, col. 7:48-50). The complaint cites a prior construction defining it as "information that must be translated before it can be executed on a processor." (Compl. ¶16, fn. 5).
- Evidence for a Narrower Interpretation: The specification states that the "code" "determine[s] various features of the dialogue protocol including the substantive content of a dialogue sequence (e.g., a sequence of dialogue prompts and user data entries)." (’897 Patent, col. 8:1-5). A defendant could argue this requires more than simple data (like a list of items) and instead requires instructional logic that defines the flow of a conversation.
The Term: "dialogue module"
Context and Importance: The complaint alleges that data packets, such as JSON data for a favorites list, are "dialogue modules." Whether this is correct will be a critical dispute. The complaint highlights a prior construction: "code or instructions related to a dialogue sequence," which refers to "a particular type of structure rather than to any structure for performing a function." (Compl. ¶¶19-20).
Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: A cited court finding states that a "dialogue module" can "contain code or other data." (Compl. ¶20). Plaintiff will argue that JSON for a favorites list constitutes this "other data."
- Evidence for a Narrower Interpretation: The emphasis on being a "particular type of structure" from the prior construction could be leveraged to argue that a simple, generic data format like JSON is not the specific structure contemplated. The specification also describes the module as containing "modified terminal code that adapts the terminal application to perform a modified dialogue protocol," which suggests a more active, code-like role than passive data. (’897 Patent, col. 7:58-60).
VI. Other Allegations
- Indirect Infringement: The complaint alleges inducement by asserting that Defendant provides the app and instructs users to download and operate it in a manner that infringes the patents, such as by using the favorites list feature. (Compl. ¶¶37, 39, 56, 58). It is alleged that Defendant "directs and controls" the users' actions through its software and contractual relationships. (Compl. ¶37).
- Willful Infringement: Willfulness is alleged based on Defendant's knowledge of the asserted patents, with the complaint establishing a knowledge date of "at least since the filing of this Complaint." (Compl. ¶¶27, 45, 64).
VII. Analyst’s Conclusion: Key Questions for the Case
- A core issue will be one of definitional scope: Can the terms "dialogue module" and "code," which the patents frame within a specific architecture for modifying interactive sequences, be construed to cover the generic data synchronization (e.g., a JSON object updating a favorites list) used in a conventional client-server e-commerce application?
- A key evidentiary question will be one of technical mapping: Does the complaint's proposed mapping—equating the patent's "computer-executable instructions" with a runtime environment (ART/CLR) and "code" with application bytecode—reflect a genuine technical distinction that was contemplated by the patent and is practiced by the accused system, or is it an artificial characterization for the purpose of litigation?
- A central dispute will likely concern the application of prior claim constructions: Given that the meanings of key terms have been addressed in prior litigation, the focus will shift to whether the specific functionalities of The Children's Place's mobile app and backend system meet those established definitions, a question of fact for the jury.