Blog

FAQ: Smalltalk to Java modernization journey for parcIT

This FQA summarizes how parcIT saved seven years by modernizing Smalltalk applications to Java with Synchrony Systems. The in-depth, 24-page report is available here.

1. Why did parcIT decide to migrate its Smalltalk applications to Java?

parcIT’s shift from Smalltalk to Java wasn’t a spur-of-the-moment decision. It was a strategic  move influenced by several pivotal factors:

  • Industry Trends: The software world was moving away from Smalltalk, making it harder to find skilled developers to maintain and enhance Smalltalk systems.
  • Customer Perception: Customers started viewing Smalltalk as a relic of the past, hurting brands of forward-thinking companies.
  • Maintenance Challenges: These were twofold. First, the general maintenance and support burden on a handful of remaining Smalltalk developers of the large and still growing Smalltalk codebase. Second, the increased complexity of the software needing to interoperate with newer product features being developed in Java.

2. What hurdles did parcIT encounter during the migration to Java?

The journey wasn’t without its fair share of bumps:

  • Dynamic vs. Static Typing: Smalltalk’s dynamic typing posed challenges when mapping it to Java’s static type system.
  • Paradigm Shifts: The “everything is an object” principle in Smalltalk, which includes primitive types, the 0-based vs. 1-based indexing of collections, full block closures vs. restricted lambda functions, and more, required a nuanced approach when translated into Java to produce maintainable software.
  • Reflection and Extensions: Smalltalk’s heavy reliance on reflection and base-class extensions didn’t have direct Java counterparts, requiring a more comprehensive transformation to a first-class alternative implementation.
  • Framework Gaps: Ensuring Java frameworks could effectively replicate Smalltalk’s core functionalities was no small feat, especially as it pertained to Smalltalk’s extensive Collection base-class library.

3. Why partner with Synchrony Systems for this modernization?

parcIT undertook an internal rewrite that was taking way too long. This made them realize they needed to find a vendor they could partner with to accelerate and, at the same time, de-risk the modernization. Key reasons for choosing Synchrony were:

  • Smalltalk Know-How: Synchrony’s deep expertise in Smalltalk, especially with migrating complex Smalltalk applications to a variety of different targets, was pivotal.
  • Advanced Tools: Synchrony’s Smalltalk Migration Technology (SMT) came loaded with features like static type inferencing, runtime type instrumentation, deep analytics, rule-based refactoring and code generation, and much more, making it a key differentiator in partner selection.
  • Collaborative Spirit: Synchrony adapted its process to allow for parcIT’s active participation and control, addressing a key requirement.
  • Cloud Advantage: Synchrony provided a dedicated AWS cloud environment to manage the entire modernization lifecycle.

4. How was the project structured to ensure success?

Success didn’t happen by chance—it was a result of meticulous planning:

  • Readiness Phase: This included a comprehensive Smalltalk source code analysis, platform dependency analysis, component interdependency, diagnostics, and challenge identification, all of which were used to build a project plan.
  • Clear Task Division: Responsibilities were clearly split between parcIT and Synchrony, with parcIT developing a Java UI Compatibility Library (CL).
  • Team Collaboration: A robust workflow ensured smooth interactions between the teams.
  • Parallel Tracks: By handling headless and GUI application migrations simultaneously, the process was streamlined, and early testing of migrated functionality was made possible.
  • Continuous Monitoring: Real-time tracking and metrics allowed for swift tactical and strategic adjustments, keeping the project on track and moving forward.

5. What strategies and tools helped overcome the technical challenges?

parcIT and Synchrony employed several smart strategies:

  • Static Type Inferencing: SMT’s engine minimized manual annotations by automatically inferring static types.
  • Runtime-Type Instrumentation: This tool boosted the accuracy of the static-type inferencing process.
  • Refactoring Base-Class Extensions: SMT refactored extensions into a separate first-class extensions framework, ensuring Java compatibility and maintainability.
  • Custom Code Generation: The SMT rule-based knowledgebase (KB) facilitated precise, flexible, customizable, and efficient code transformation.
  • Migration Subsets: Breaking down the codebase into smaller units made the migration easier to manage and test.

6. What were the key takeaways from the modernization?

parcIT learned several valuable lessons:

  • Collaboration Pays Off: Active team involvement led to higher code quality and a smoother transition of migrated Java code ownership.
  • Front-Loaded Effort: The initial stages, especially static-type inferencing, required significant upfront effort.
  • Continuous Improvement: Regular updates to the migration tools were crucial for success.
  • Impact Analysis: Careful evaluation of potential scope changes during the project was essential.

7. What benefits did parcIT reap from the modernization?

The migration brought about numerous advantages:

  • No More Legacy Issues: The previous Smalltalk challenges were eliminated with the switch to Java.
  • Faster Completion: Automation significantly reduced the time needed to complete the modernization compared to a manual rewrite.
  • Easier Maintainability: The new Java codebase made it easier to integrate with internal Java applications, making the software easier to scale and adapt for future needs.
  • Enhanced Perception: Offering solutions on a modern platform improved parcIT’s competitive advantage.

8. How did parcIT optimize the migrated codebase post-modernization?

Post-migration, parcIT focused on fine-tuning:

  • Reducing Reflection: Incrementally cutting down reflection usage improved performance and maintainability.
  • Minimizing Type Casting: Addressing type casting instances made the code more readable and reduced potential runtime errors.
  • Performance Tweaks: They optimized Compatibility Library (CL) APIs to eliminate performance bottlenecks.

Through a combination of strategic planning, collaboration, and innovative tools, parcIT successfully navigated the complex journey from Smalltalk to Java, setting itself up for a more agile and sustainable future.