She spent six hours trying to mimic the JNLP's environment. She set up a Windows XP virtual machine. She installed Java 6 update 21. She disabled all security updates. She copied the exact JARs from the old server's cache. Still, the application would launch, show a gray window, and crash with a NullPointerException at a line that simply read: String s = null; s.length(); .
She closed her laptop at 11:47 PM. On the screen, a single line of Python remained:
<?xml version="1.0" encoding="UTF-8"?> <jnlp spec="1.0+" codebase="http://legacy-box:8080/actuarial/"> <information> <title>Loss Run Generator</title> <vendor>GIC Legacy Systems</vendor> </information> <resources> <j2se version="1.6+" java-vm-args="-Xmx512m -XX:PermSize=128m"/> <jar href="actuarial-core.jar" main="true"/> <jar href="pdf-generator-2009.jar"/> <jar href="apache-xerces-2.9.1.jar"/> <jar href="jai-core-1.1.3.jar"/> </resources> <application-desc main-class="com.gic.legacy.LossRunMain"/> </jnlp> "Convert JNLP to PDF," she muttered, tasting the absurdity. It was like saying "convert a car engine to a croissant." One was a deployment descriptor for old Java applications. The other was a document format. But the business need was real: inside that JNLP was the recipe for a PDF. And she needed to extract it.
She wrote a Python script. Not because Python was the best tool, but because it was the most forgiving. She used subprocess to call a small Java CLI tool she wrote in twenty minutes. That Java tool did only one thing: loaded the old JARs (including iText 2.1.7 and the Xerces XML parser) into a custom classloader, instantiated the PDFBuilder class via reflection, and exposed a simple method: byte[] generatePdf(String xmlData) . convert jnlp to pdf
Then, the application would take that XML, run it through a series of XSLT transformations (the apache-xerces JAR), feed the result into the pdf-generator-2009.jar (which was a thin wrapper over iText 2.1.7, a version so old it predated PDF/A standards), and finally spit out a byte array that was written to C:\legacy_reports\output.pdf .
Elena Vasquez, a senior cloud architect with fifteen years of experience, had never heard of JNLP until that Tuesday morning. She had been hired by Global Insurance Corp to "modernize their document pipeline." The previous architect, a man named Harold who had retired to a shrimp boat in Louisiana, had left behind a sprawling, undocumented Java Web Start application. Every morning at 4:00 AM, a cron job on a dusty Windows Server 2008 machine would trigger a JNLP file. That file would reach out to a legacy SOAP service, pull actuarial data, and generate a PDF report. For fifteen years, it had worked. Until it didn't.
Elena realized she didn't need the GUI. She didn't need the JNLP launcher. She needed the transformation pipeline. She spent six hours trying to mimic the JNLP's environment
It began as a whisper. Not the kind of whisper you hear in a crowded room, but the kind that lives deep inside a system log, a forgotten dependency, a legacy application that no one dares to touch. The whisper came from a file named legacy-report.jnlp .
The next morning, she deployed her solution as a scheduled Lambda function. At 4:00 AM, the old cron job tried to run the JNLP and failed. But at 4:01 AM, her Lambda woke up, called the SOAP service, ran the Java bridge, and deposited a pristine PDF in a compliance bucket. She even added a small script that emailed Gerald: "Loss run report ready. (Legacy conversion successful.)"
But Elena knew the truth: she hadn't "converted JNLP to PDF." She had reverse-engineered a zombie. The JNLP was still dead. But its brain—the transformation logic, the JARs, the XSLT—was now puppeted by modern code. She disabled all security updates
The email arrived at 8:47 AM, marked "URGENT: Regulatory Deadline." The compliance officer, a tense man named Gerald, explained that the state insurance commission required the previous month's loss runs by Friday. Today was Wednesday. The JNLP launcher was throwing an Unrecognized VM option 'PermSize' error. The server's Java 8 update had been forcibly pushed by an overzealous security patch. Java Web Start had been deprecated, then removed entirely. The PDFs had stopped.
Elena stared at the .jnlp file in Notepad++. It looked like an alien artifact:
That night, Elena sat in her home office, the glow of three monitors painting her face blue. She opened the JNLP again. Not as code, but as a puzzle. The JNLP wasn't the enemy. It was a map. It pointed to resources, to a main class, to JVM arguments. The PDF was in there somewhere.
Now the challenge: she needed to "convert JNLP to PDF" in a way that was automated, serverless, and modern. She couldn't run the JNLP anymore. But she could extract its soul.