DCT
4:23-cv-00011
S3G Technology LLC v. Buckle Inc
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: The Buckle, Inc. (Nebraska)
- Plaintiff’s Counsel: PARKER, BUNT & AINSWORTH, P.C.
- Case Identification: 4:23-cv-00011, E.D. Tex., 01/05/2023
- Venue Allegations: Plaintiff alleges venue is proper because Defendant maintains a regular and established place of business in the district and has transacted business involving the accused products in the district.
- Core Dispute: Plaintiff alleges that Defendant’s mobile applications and associated backend systems for e-commerce infringe three patents related to methods for efficiently modifying software applications on remote devices.
- Technical Context: The technology addresses the challenge of updating software on a large number of distributed devices, such as mobile phones, by sending small "dialogue modules" to modify application behavior rather than transmitting large, complete software updates.
- Key Procedural History: The complaint references a prior case, S3G Tech. LLC v. Unikey Techs., Inc., and cites claim constructions from that proceeding for the terms "code" and "dialogue module," suggesting these terms will be central to the present dispute. The complaint also references the prosecution history of the ’571 Patent, quoting a Notice of Allowability to argue for the novelty of a system that distinguishes between directly executable instructions and translatable "code."
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Earliest Priority Date for ’571, ’124, and ’082 Patents |
| 2013-07-11 | ’571 Patent Notice of Allowability Issued |
| 2013-10-29 | ’571 Patent Issued |
| 2018-04-10 | ’124 Patent Issued |
| 2021-12-28 | ’082 Patent Issued |
| 2023-01-05 | Complaint Filed |
II. Technology and Patent(s)-in-Suit Analysis
U.S. Patent No. 8,572,571 - Modification of Terminal and Service Provider Machines Using an Update Server Machine
- Patent Identification: 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 patent’s background describes the difficulty, expense, and inefficiency of distributing newly compiled software updates to a large number of remote devices, particularly over wireless networks with limited bandwidth (Compl. ¶14-16; ’571 Patent, col. 2:1-52). Transmitting an entire new application is often slow and impractical (Compl. ¶16).
- The Patented Solution: The invention proposes a three-entity system comprising a terminal machine (e.g., a mobile device), a service provider machine (e.g., a backend server), and an update server machine (Compl. ¶17). Instead of sending a full application update, the update server sends a small "dialogue module" containing "code." This "code" is defined as information that must be translated by the application before it can be executed, distinguishing it from directly "computer-executable instructions" which form the application's stable core (’571 Patent, col. 4:21-25). This module modifies the application's behavior, enabling updates without large data transfers (Compl. ¶17, ¶21). The complaint reproduces Figure 1 from the patent to illustrate this three-part system architecture (Compl. ¶17).
- Technical Importance: This approach claims to reduce network bandwidth utilization and improve the efficiency of modifying applications running on remote devices (Compl. ¶25).
Key Claims at a Glance
- The complaint asserts direct infringement of at least Claim 2, which depends on independent Claim 1 (Compl. ¶28).
- Essential elements of independent Claim 1 include:
- A system comprising an update server machine, a terminal machine, and a service provider machine.
- The update server sending a "terminal dialogue module" to the terminal machine and a "provider dialogue module" to the service provider machine.
- The terminal application comprising a "first set of computer-executable instructions" (able to execute directly) and a "first set of code" (not able to execute directly).
- The terminal dialogue module modifying the first set of code to produce a "first set of updated code," which adapts the terminal application to use a second sequence of prompts and data entries.
- The provider dialogue module similarly modifying a "second set of code" on the service provider machine.
- Crucially, the dialogue modules do not modify the sets of computer-executable instructions.
U.S. Patent No. 9,940,124 - Modification of Terminal and Service Provider Machines Using an Update Server Machine
- Patent Identification: 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: As with the ’571 Patent, the technology addresses the challenges of updating remote software over bandwidth-constrained networks (Compl. ¶14-16).
- The Patented Solution: This patent claims a method for conducting a dialogue between a terminal and a service provider. The method involves the terminal machine running an application composed of "first computer-executable instructions" and "first code" (Compl. ¶43). The terminal receives a "terminal dialogue module" that "updates at least a portion of the first code to produce first updated code." This updated code adapts the application to display a new prompt as part of a modified dialogue sequence (Compl. ¶47). The complaint reproduces Figure 2 from the patent family to illustrate the application structure of executable instructions (224) and translatable code (222) (Compl. ¶18).
- Technical Importance: The method provides a way to alter application functionality and user interaction flows on a remote device without sending a complete, recompiled application (Compl. ¶25).
Key Claims at a Glance
- The complaint asserts direct infringement of at least independent Claim 1 (Compl. ¶41).
- Essential elements of independent Claim 1 include:
- A method of conducting a dialogue between a terminal machine and a service provider machine.
- Displaying a first prompt on the terminal via a terminal application comprising first computer-executable instructions and first code.
- Accepting a first data entry and communicating it to the service provider machine.
- Storing at least a portion of the information in memory for analysis.
- 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 first updated code adapting the terminal application to display a second prompt for a modified dialogue sequence.
- A requirement that at least one of the first code, second code (on the provider machine), and first updated code comprise "intermediate code."
U.S. Patent No. 11,210,082 - Modification of Terminal and Service Provider Machines Using an Update Server Machine
- Patent Identification: U.S. Patent No. 11,210,082, "Modification of Terminal and Service Provider Machines Using an Update Server Machine," issued December 28, 2021.
- Technology Synopsis: This patent claims a method performed by a service provider machine for conducting a dialogue. The provider application, which comprises both directly executable instructions and translatable "code," receives and stores information from a user (Compl. ¶57-59). It then receives "second code" that supplements or replaces its existing code to produce "first updated code," adapting the application for a modified dialogue. Finally, it sends "third code" to a recipient to facilitate the recipient's part of this modified dialogue (Compl. ¶60-61).
- Asserted Claims: At least independent Claim 1 (Compl. ¶56).
- Accused Features: The complaint alleges that Defendant's server (the service provider machine) infringes by running a .Net application that receives user information (e.g., adding a "favorite item"), stores it, and receives new data in JSON format (the "second code") which supplements the application's existing code. The server then allegedly sends "third code," also in JSON format, back to the user's mobile app to facilitate the updated user experience (Compl. ¶57-61).
III. The Accused Instrumentality
Product Identification
The "Accused Instrumentalities" or "Accused System" include Defendant’s BUCKLE mobile applications for Android and iOS (collectively, "Defendant app"), as well as the supporting systems, servers, software, and computing devices that facilitate the app's use (Compl. ¶8).
Functionality and Market Context
The Accused System provides an e-commerce platform for Defendant's customers. The complaint focuses on the technical architecture for features such as managing "favorite items," wish lists, purchase history, and payment methods (Compl. ¶30, n.7). The infringement theory posits a three-machine architecture: the user's smartphone running the Defendant app is the "terminal machine," Defendant's backend server is the "service provider machine," and either the smartphone or the server can function as the "update server machine" (Compl. ¶29-32). The complaint alleges that when a user interacts with a feature like "favorite items," data is sent between the app and the server in formats like JSON, and that this data constitutes the claimed "dialogue modules" that modify application behavior (Compl. ¶30, ¶47).
IV. Analysis of Infringement Allegations
’571 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| an update server machine comprising a processor and operable for sending a terminal dialogue module to the terminal machine and a provider dialogue module to the service provider machine... | The Accused System includes an update server (e.g., a smartphone or Defendant's server) that sends a terminal dialogue module (e.g., data for a "favorite item") to the user's app and a provider dialogue module to the Defendant's server. | ¶30 | col. 6:20-30 |
| wherein the terminal application comprises a first set of computer-executable instructions and a first set of code, wherein the first set of computer-executable instructions are able to execute directly on a terminal processor..., and wherein the first set of code is not able to execute directly... | The Android app comprises the Android Runtime (ART) as the directly executable instructions and the app's bytecode as the code that cannot be directly executed and must be translated. | ¶31 | col. 7:36-45 |
| wherein the terminal dialogue module modifies the first set of code to produce a first set of updated code wherein the first set of updated code adapts the terminal application to use a second sequence of prompts... | The terminal dialogue module (e.g., data for a favorite item) modifies the app's bytecode to produce updated code that adapts the app to use a new sequence of prompts, such as when a new favorite item is added and appears on the user's device. | ¶33 | col. 8:44-52 |
| wherein the terminal dialogue module does not modify the first set of computer-executable instructions... | The terminal dialogue module does not modify the Android Runtime (ART). | ¶33 | col. 8:30-33 |
’124 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| a method...comprising: 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... | The Defendant app, running on a user's smartphone, displays prompts for actions like reviewing favorite items or placing orders. The app comprises the Android Runtime (executable instructions) and the app's bytecode (code). | ¶43 | col. 12:4-10 |
| 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 user's smartphone receives a terminal dialogue module (e.g., information about a favorite item sent from the server in JSON format) that updates the app's bytecode to produce updated code. | ¶47 | col. 12:20-25 |
| 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 updated code adapts the app to display a second prompt, evidenced by the ability to access new favorite items after they have been added. | ¶47 | col. 12:25-30 |
| wherein at least one of the first code, the second code, and the first updated code comprise intermediate code. | The app's bytecode, which constitutes the first code, is identified as intermediate code. | ¶47 | col. 12:33-35 |
- Identified Points of Contention:
- Scope Questions: The infringement theory hinges on whether data packets (e.g., JSON objects representing a "favorite item") can be considered a "dialogue module," which a prior court construed as referring to "a particular type of structure" (Compl. ¶22). A central question may be whether simple data constitutes the specific "structure" contemplated by the patents, or if the patents require a module containing executable logic or control flow information.
- Technical Questions: A key technical question is whether the alleged "dialogue module" (a JSON object) actually "modifies the first set of code [bytecode] to produce a first set of updated code" as the claims require (Compl. ¶33, ¶47). The analysis may focus on whether the app's bytecode is truly altered, or if the existing, unmodified bytecode simply processes the incoming JSON as data to update the application's state. Similarly, the mapping of the Android Runtime (ART) to the "computer-executable instructions" of the "terminal application" may be scrutinized, raising the question of whether a runtime environment can be considered part of the application itself for the purposes of the claim.
V. Key Claim Terms for Construction
The Term: "code"
- Context and Importance: The patents' novelty argument, as presented in the complaint, rests on the distinction between this "code" and directly "computer-executable instructions" (Compl. ¶26). The infringement case depends on mapping this term to an application's bytecode (Compl. ¶31). Practitioners may focus on this term because its construction will determine if the patents' core inventive concept reads on modern mobile app architecture.
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: The specification defines "code" as "at least some information that must be translated by the software application before it can be implemented on the machine processor" (’571 Patent, col. 4:21-25). This definition could support an interpretation covering any form of interpreted or just-in-time compiled code, such as mobile app bytecode.
- Evidence for a Narrower Interpretation: The context of the patent describes this "code" as being delivered in a "dialogue module" to effect a change in a dialogue sequence. A defendant might argue that the term, when read in light of the specification's examples, refers to a specific set of rules or logic for a dialogue, not the entirety of an application's general-purpose bytecode.
The Term: "modifies the first set of code to produce a first set of updated code"
- Context and Importance: This phrase describes the central mechanism of the invention. The infringement allegation is that receiving a JSON object about a favorite item performs this function (Compl. ¶33). The case may turn on whether this functional language requires an actual alteration of the bytecode file itself or can be met by simply providing new data for the existing code to process.
- Intrinsic Evidence for Interpretation:
- Evidence for a Broader Interpretation: A plaintiff may argue that "modifies" should be interpreted functionally. From the application's perspective, receiving the new data results in a modified behavior (a "modified dialogue sequence"), and the combination of the original code plus the new data functions as "updated code."
- Evidence for a Narrower Interpretation: The claim language specifies that the "dialogue module modifies the first set of code." This could support a narrower reading that requires a direct change to the code instructions themselves, such as replacing a block of bytecode or patching a function, rather than merely providing new input data to an unchanged set of instructions.
VI. Other Allegations
- Indirect Infringement: The complaint alleges inducement by Defendant "marketing, promoting, and offering for use the Accused Instrumentalities" and encouraging users to download and run the Defendant app, allegedly with knowledge that its use infringes (Compl. ¶34, ¶48, ¶62). Contributory infringement is also alleged on the basis that the Accused Instrumentalities are not staple articles of commerce and are especially adapted for infringement (Compl. ¶35, ¶49, ¶63).
- Willful Infringement: The complaint alleges Defendant has had actual knowledge of the asserted patents "At least since the filing of this Complaint" (Compl. ¶27, ¶40, ¶54). The prayer for relief requests a finding of willfulness, suggesting a theory based on post-filing conduct (Compl. p. 28).
VII. Analyst’s Conclusion: Key Questions for the Case
- A core issue will be one of technical and definitional mapping: can the patents’ conceptual division between directly executable "instructions" and translatable "code" be validly mapped onto a modern mobile operating architecture, where the "code" is alleged to be an application's bytecode and the "instructions" are the underlying runtime environment (e.g., Android's ART)?
- A key evidentiary question will be one of functional mechanism: does receiving a data structure, such as a JSON object describing a "favorite item," perform the claimed step of "modifying" the application's "code" to produce "updated code," or does this represent a fundamental mismatch in technical operation where an unchanged application code simply processes new data?
- The resolution of this case will likely depend on whether the court construes the patent claims to cover the general architecture of modern app ecosystems or to require the more specific mechanism of patching or replacing sections of application code as described in the specification.