In industrial automation, software command sets shape how engineers interact with complex tools. They can provide a consistent vocabulary for specifying tasks, configuring analyses and moving between related applications. A 2020 amicus brief filed by Synopsys in Google LLC v. Oracle America, Inc. argued that these command interfaces can also embody creative choices—not merely describe software functions. The brief offers a useful perspective for automation developers and decision-makers evaluating software reuse, compatibility and intellectual property.
Why software command sets matter
Synopsys develops electronic design automation (EDA) software used to design and test computer chips. In its brief, the company described command sets that allow chip designers to direct complex tools through commands and parameters. Its synthesis software helps users translate an abstract description of a chip’s intended capabilities into a design layout. Its signoff software evaluates whether a design is expected to work as intended and checks for potential vulnerabilities.
These products perform different tasks, but Synopsys said their command sets are harmonized so that users familiar with one product line can work with another using shared language choices. In this account, a command interface is not incidental to the software. It affects how users express instructions and how they move among functions.
That point has a clear parallel in industrial automation software. Engineers and system integrators rely on defined commands and parameters to interact with specialized tools. The brief does not establish how any particular automation interface would be treated under copyright law; rather, it raises questions about when the language and arrangement of software commands may reflect original expression.
How a command can express more than a function
A software function and the way a programmer describes or invokes it are related, but they are not necessarily identical. The Synopsys brief argued that copyright protects expression rather than an underlying idea, process or method of operation. Applied to commands, its position was that a function may be necessary, while the particular name, combination of words and way of organizing related commands can involve choices.
For example, a command that invokes a timing-analysis assumption can identify the action, refer to relevant variables and indicate the condition under which the action applies. Synopsys presented a lengthy command from its PrimeTime timing-analysis software as an example of a naming choice that describes both the operation and its conditions. The brief argued that other names could have been chosen to express the same function.
This distinction matters to software teams because functional compatibility does not always require copying a particular expression. In the brief’s reasoning, developers may be able to implement equivalent behavior using different names or structures. Whether alternatives are genuinely practical is a technical and legal question that depends on the software and the circumstances; the brief’s argument was not that every command or interface is automatically protected.
Command organization can be part of the design
The brief also addressed how software functions are grouped and arranged. Synopsys argued that organizing commands into a coherent system involves choices, much as creating a taxonomy involves decisions about classification. A command library may therefore reflect design in both its individual elements and its overall structure.
For automation product teams, this invites a broader view of interface development. Decisions about command names, parameter conventions and consistency across related tools can shape the user experience. The brief emphasized that familiar language across product lines can help users apply existing knowledge to another product. It also described the resources Synopsys said it invested in developing and refining its command sets.
What the brief argued about fair use
Copyrightability and fair use are separate issues. Even if a work contains protectable expression, a particular use may still be argued to qualify as fair use under applicable law. In the Supreme Court case, Synopsys filed in support of Oracle and argued that Google’s use of Oracle’s declaring code was not fair use. These were the amicus brief’s arguments, not a general rule established for every software interface.
The brief disputed the idea that using code in a different product or on a different platform automatically makes the use transformative. It argued that the key question was what the copied code did: if it performed the same function in the new product, a change in platform alone did not change the purpose of the expression. It also maintained that evaluating the amount copied requires considering qualitative importance, not only the percentage of a larger code library.
Finally, Synopsys argued that using copied code in a commercial product could affect the original creator’s market and potential derivative markets. The practical concern it raised was that broad permission to reuse expressive elements could make it harder for developers to benefit from investment in software. The brief’s position was that protecting original expression can support continued development, while recognizing that copyright does not extend to ideas and functions themselves.
Practical implications for automation teams
Industrial automation organizations can take several measured lessons from the debate:
- Separate behavior from expression. Document functional requirements independently from existing command names and interface structures when developing alternatives.
- Review reuse deliberately. Do not assume that a command or code element is free to copy simply because it is familiar, efficient or widely used.
- Record design decisions. Clear documentation of independently developed names, structures and implementations can help explain how a software interface was created.
- Include legal review. Compatibility, interoperability and reuse questions can involve technical details as well as legal analysis. Escalate material uncertainties to qualified counsel.
Conclusion
The Synopsys amicus brief presents software command sets as designed interfaces whose names and organization may contain expressive choices alongside functional purpose. For industrial automation developers, integrators and buyers, the central takeaway is to distinguish the behavior a tool must provide from the particular language and structure used to provide it. Thoughtful interface design, careful reuse practices and appropriate legal review can help teams address that distinction without treating the brief’s arguments as a universal conclusion about software copyright.