Smalltalk to Web 2.0 Modernization Solution

Migrate, transform and modernize your mission-critical, client/server Smalltalk applications to a distributed and scaleable Web architecture and platform.  This is the most advanced and comprehensive automated Smalltalk migration and modernization solution available in the marketplace today!  It guarantees functional equivalence and eliminates end-user retraining. It dramatically reduces risk, cost and failure inherent in a rewrite. Gain a massive market advantage by rapidly migrating your desktop GUI applications into a a single-page JavaScript rich-client with zero-deployment web front-end powered by industrial-strength Java EE or .NET mid-tier application server back-ends, or open source, cross-platform Node.js server-side runtime environment.

No more more screen scraping! No more remote desktop sessions!

Incremental Smalltalk Modernization - Production

"As-Is" transformation

  • "As-Is"

  • Fat-client

  • No retraining

Web transformation

  • GUIs in the Browser
  • Distributed
  • No retraining

Mobile / transformation

  • Modernized for mobile
  • Modern orchestration of UI
  • Cloud & microservices ready

Incremental Smalltalk Modernization - Development

Eclipse IDE/Visual Editor

  • Widget palette with rich UI widgets

  • Support for constraint-based widget layout

  • Dependencies expressed in code  (no "visual spaghetti")

2.2 black arrow.png

VisualAge Composition Editor

  • Visual parts

  • Non-visual parts

  • Connections (visual "visual spaghetti")


Incremental Smalltalk Modernization - Architecture

Web Client Tier

  • Thin-client (JavaScript)

  • Interactive, rich UI

  • REST API calls

Service Middle Tier

  • Web Application Server

  • REST/Web Services

  • Java/C#/Node.js application logic

Host Tier

  • Continue with high performance

  • Continue with high reliability

  • Continue with high security

 

Smalltalk Transformation Technology Features

 
2. Type Inferencing.Animated.gif

Static Type Inferencing

The only commercial interactive, static type inferencing and type propagation solution available on the market today. Using static type analysis and proprietary type inferencing algorithm, this technology produces a "strongly-typed" Smalltalk source code that includes generic / parameterized types and interfaces. Absence of this technology is a non-starter for migrating Smalltalk applications to any target statically typed language as it would cause massive code expansion and highly unreadable and unmaintainable code. 


3 Diagnostics.Animated.gif

Interactive Diagnostics

Interact with context sensitive, configurable, extensive and self-resolving diagnostics as you transform your application. Just as compilers generate compiler errors, the interactive diagnostic service generates comprehensive diagnostics relative to the target language your Smalltalk application is being transformed to. Diagnostics include any static type inconsistencies, naming, missing mapping of types or API's to target language, code quality, dead code, just to name a few... 


4.Transformation.Animated.gif

Source-code Transformation

Reduce Total Cost of Ownership by managing external knowledge-base ("KB") rules that control resultant code quality by executing the KB rules with an automated transformation service. This technology is a full-blown OO programming language that operates on abstract syntax trees ("AST"). Source code transformation not only transforms artifacts types and their interfaces to target programming language; is it also used extensively for code cleanup, code formatting and a much more advanced capability, which is code decoupling to separate monolithic architecture into distributed, microservices architecture.


5. Architecture Analysis.Animated.gif

Architecture Analysis & Drill-down

Define logical and functional source code components to improve knowledge mining and application understanding. This technology is used on more advanced modernization projects to describe and define a complete target application architecture in terms of 4 different dimensions: 1) application layers 2) subsystems 3) cross-cutting functions and 4) runnable components. This is not just a simple data model. Its a live semantic model that describes the application architecture in terms of real code artifacts that subsequently enables drill-down for deeper application understanding and transformation.


Ready to get started?