Projects

Some representative projects undertaken by SoftwareLitigationConsulting.com include:

  • Numerous inspections of binary/object code in software products, internet services, and mobile devices, to show (or rebut) patent infringement
  • Numerous source-code examinations under protective order, to show infringement, non-infringement, invalidity, or working/practicing of patent (e.g. to show “domestic industry” in ITC actions)
  • Construction of scripts to automate source-code examination (e.g. to extact relevant functions from 100 different versions of source-code tree on other side’s source-code computer)
  • Designed and wrote software to generate spreadsheet to find similarities between over 1,000 Java source code files found on defendant’s computer on the one hand, with Java source code contained in plaintiff’s PVCS version-control archive on the other.
  • As demonstrative exhibit for trial, constructed timelines showing correlation between defendant’s internal emails and code in its shipping product.
  • Based on examination of voicemail system used by defendant, determined defendant’s ability to respond to discovery request by keyword-searching archived voicemails.
  • Designed and wrote software that uses Java decompiler to automatically find similarities between plaintiff’s and defendant’s binary Java .class files, without access to source code.
  • Designed and wrote software that uses Win32/x86 disassembler to automatically compare DLLs and other compiled binary Win32 software, without access to source code. In addition to being used in several software litigation projects, this technique is described in a three-part series: Andrew Schulman, “Finding Binary Clones with Opstrings and Function Digests,” Dr. Dobb’s Journal, July 2005 (Part I), August 2005 (Part II), September 2005 (Part III).
  • After comparing claims table based on plaintiff’s patent on the one hand with pseudocode for defendant’s software on the other, constructed demonstrative exhibits showing divergence between patent claims and allegedly infringing software.
  • Wrote software to automate ranking of patent portfolios, based upon intrinsic and extrinsic factors; used software to rank portfolio of over 500 software patents based on relevance to potential infringer’s technology.
  • Designed and wrote software to automatically inspect binary code files to determine inter-module dependencies, and thereby partition system of over 2,000 DLLs into separable components.
  • Using Windows ToolHelp facility, designed and wrote software to determine the modules used uniquely by (and therefore comprising) Win32 applications running on Windows XP.
  • Using Windows NT kernel device drivers, designed and wrote software to measure use of litigated microprocessor special flags by each process on NT/Win2K/XP systems.
  • Given error messages displayed by defendant’s product when plaintiff’s software is run, used Windows and DOS disassemblers and debuggers to trace back from the error messages to the lines of code that produced them; wrote reports assessing whether the error messages were technically necessary, bugs, or deliberate incompatibilities.
  • Used packet sniffers to examine encrypted communications between defendant’s client software and plaintiff’s server.
  • To show lack of technical necessity for overlap between defendant’s and plaintiff’s C++ and JavaScript code, wrote more efficient versions of code.
  • Wrote device drivers to help attach external Tekronix counting device to Pentium debug registers, in order to measure usage of operating-system features.
  • Automated comparison between over 1 million lines of source code (C/C++, Java, Visual Basic, HTML, resource scripts, help scripts, etc.) produced by defendants and plaintiffs, to find percentage overlap, while filtering out common boilerplate code, and code “constrained” by the application domain; reported results in terms of Altai abstraction-filtration-comparison test.
  • Examine binary and source code to show evolution of software over five versions, measuring percentage overlap between each, and showing that despite minimal overlap between first and last version, defendant’s first version (stipulated to be based on plaintiff’s software) acted as “scaffolding” within which defendant’s final version was constructed.
  • Designed and wrote scripts to verify whether software to be removed from system under court order was, in fact, truly and completed removed.
  • Used packet sniffer to verify compliance of client/server communications with web site privacy notice.
  • Used sequences of API calls in binary code as “fingerprints” to show similarity between defendant’s and plaintiff’s code, for which source code was not yet produced in discovery.