Month: March 2017

    Let’s Get Technical – Extensibility

    2 Comments
    Extensibility

    In our last post we discussed the Morphis low code development framework delivered with our modernized legacy applications to underpin their ongoing maintenance and enhancement. We left the extensibility discussion to this post.

    A discussion on extensibility is best illustrated with a real life case study for which we’ll use Ellucian and the modernization of their Banner® Student Information System from Oracle Forms to Java. This modernization included the provision of an extensibility framework which enables Ellucian’s clients to customize their UI data entry forms to ensure adherence to their own unique policies without having to modify the base source code.

    This is a key feature of extensibility. No longer does the end user have to update the underlying code, reapply their existing customizations and test functionality (assuming they remember what those customizations are); no longer is Ellucian having to deal with changes to their base code in the field. This is what the extensibility framework has delivered to Ellucian and their customers.

    Having modernized the core Banner system there are, of course, many customizations in the field that also need modernizing. To enable scoping of those customizations, Ellucian leverage Morphis’ Inspector tool. The video below is from Ellucian Live in March 2017 where Morphis and Ellucian discuss the process for Ellucian’s clients in modernizing those customizations. Unfortunately the audio is not great but the whole session is audible with a little perseverance.

    So what is the Morphis technology underpinning extensibility? The extensibility of Tasks and the inheritance model that Mprphis has implemented uses Morphis Foundations and even Morphis Frames, thereby, also enabling inheritance in Views.

    Foundations enables the addition of new business objects, controls, controller methods and service methods, as well as the modification of something that already exists. Different parts of the same Form can even inherit from separate parents while adhering to the single-inheritance rules of .NET and Java. 

    The basic extensions that can be implemented and combined include:

    1. Modification of visual properties and items within an existing view;
    2. Addition of new visual blocks and items to an existing view;
    3. Creation of new items in existing domain concepts (business objects);
    4. Creation of new domain concepts (business objects);
    5. Modification of existing action triggers functionality;
    6. Addition of new action triggers to baseline or extension elements.

    An overview and demonstration of the extensibility process is provided by the following video.

    If you have any questions or would like to learn how this can be applied to your situation, please do not hesitate to contact us.

    Categories: Morphis Technology Update Tags: Tags:

    Let’s Get Technical – Low-Code Development

    4 Comments
    Low Code Development

    The Morphis technology platform was developed to enable the modernization of legacy systems, written in any language, to cloud-ready Java or .NET environments. The goal is to achieve 100% automation and we continue to strive for this (we’re closer in some legacy languages than others) but where this is not possible we offer productivity tools to make code completion and UI tuning as efficient as possible.

    A representation of the technology platform is as follows:

    A 3 stage process of Analyze, Modernize (Transform) and Develop. The Analyze stage has been covered in previous posts, perhaps most extensively here. The Modernize (or Transform) stage is highly automated and follows this process.

    Note that customizations/enhancements can be built into the automated Modernize process providing further cost/time efficiencies over building them in afterwards/rewriting the application.

    This post focuses on the final stage – Develop, and specifically the low-code development platform we have created to support the ongoing maintenance and enhancement of modernized applications. Why did we build this? Because technical debt is for life and not just a one-time blight on your application. The speed of technological change is such that you need to learn to fish.

    An application modernized by Morphis will follow the MVC (Model, View, Controller) pattern and will be built using the Morphis Frames (View) and Foundations (Model/Controller) frameworks.

    Both Frames and Foundations provide a low-code approach to developing web-data-driven applications, encouraging developers to focus on writing application logic rather than infrastructure, which is provided by support libraries. Note that there no runtime dependencies/licenses required so your application can be delivered/licensed entirely independent of the Morphis frameworks.

    The architecture is explained at a high (technical) level in the following video. Note that all of the videos were created using a Java target environment but exactly the same principles hold for a .NET environment where we surface via a Visual Studio plugin.

    The Model layer maintains the data (loaded from the database) for manipulation in the application and is explained in detail in this video.

    The View layer is implemented using Morphis Frames whose WYSIWYG UI enables design independent of target technology and, consequently, a write-once, reuse anywhere on any device paradigm. It is described in further detail in the following video.

    The Controller layer sits between the presentation layer and the back-end and handles all communication and triggers such that the application code can be totally independent of the presentation technology. It is explained in detail in the following video.

    And then there’s extensibility…but that’s for another day. Watch out for our next post to learn more on how we support extensibility. Better still, subscribe below and you’ll receive an update notification in your inbox. And, no, we won’t spam you. Any questions? You can use the Contact tab above or use the Q&A box that appears as you scroll down the page. We’re a responsive bunch  – pun intended if you’re looking for a mobile-enabled app!!

    Oracle Forms Modernization – Get Started Today!

    1 Comment
    Oracle Forms Modernization - The Clock is Ticking

    The clock is ticking for Oracle Forms Modernization. Extended support for Oracle Forms and Reports versions 12 ends in 2025. Premier support will end in two years. Here is the Oracle Lifetime Support Policy for Forms and Reports 12c.

    Oracle Information-Driven support

    Are you still running a stack to support Forms and Reports based applications? You’re not alone, but the clock is ticking.

    The good news is that you have a choice – other than following the prescribed Oracle upgrade path. Morphis has been modernizing Oracle Forms and Reports to a Java or .NET stack for many years. You can get started by clicking the download button below (but keep reading first).

    “While we looked at several, there wasn’t another vendor that could execute with the same level of proficiency as Morphis. Their technology was vastly superior to anyone else we considered.”Kari Branjord, senior vice president, strategy and product management, ERP at Ellucian.

    Or check out the success we had at Miami-Dade County where both Java and .NET were targeted across the 20+ applications modernized.

    “One of the reasons we chose Morphis is because of their flexibility to re-architect to either Java or .NET, and because they have the capability to convert an Oracle database to a SQL Server database. Since we were 100 percent Oracle, this piece was critical. As far as outcomes, the tech guys we work with are phenomenal. They do everything they can to make us successful and we stay with them because we know what they can do.”Sue Camner, Database Manager of Miami-Dade County.

    Note that Miami-Dade moved to a SQL Server database but you have the choice of maintaining your database or migrating that too. It’s up to you.

    Some of the Miami-Dade applications were modernized by Miami-Dade developers using the Morphis platform with training and support from us. Others were completed jointly, some were delivered entirely by Morphis. If you have developers that you would want to apply to the Oracle forms modernization projects then we can support you. Again it’s your choice.

    How do you get started? Fill out this contact form to receive a copy of our Inspector tool. This is a tool that you will run and which will extract meta data on your application that you send back to us for analysis. From there we will provide you with an initial estimate (time and cost) for a 1:1 transformation of your app to a Java or .NET stack (i.e. the same functionality as the source application).

    Get Your Copy of Morphis’ Inspector Tool


    Further, if you wish to build new functionality into the product as part of the automatic transformation process, we can do that too (but we’d need to quote separately for that). Things like accessibility, responsive design, extensibility, SSO are all routinely built into the automatic transformation process making Morphis even more cost effective and time efficient.

    What are you waiting for? Follow this link to get our free tool and no obligation initial estimate.

    Too Good To Be True?

    Tom Robinson Too Good To Be True

    I have a confession to make. Well, two actually. Firstly, I am new to the legacy modernization space. This is only the end of my second year pondering and wondering why so many make such a meal of something that, frankly, isn’t that difficult.

    There, I said it. This really isn’t that difficult. Certainly not as difficult as most people make it out to be.

    The second confession is that I am old enough (just) to remember Tom Robinson’s song ‘Too Good To Be True’ hitting the UK charts in 1978. If you missed Tom, he’s one of the greatest British songwriters of all time…

    The connection between the two? Well that came from a recent partner meeting. At Morphis we’re keen to extend our market reach through partners [delivering modernization services based on our technology platform] and we were demonstrating the Morphis platform to a new, prospective parter. And I should add, not a partner new to the space (like me) but a company with decades of experience modernizing legacy systems.

    During a follow-up call a week or so afterwards my contact at the partner said, “I hope you don’t take this the wrong way, Neil, but it all looked too good to be true.”

    We’d only showed the automatic transformation of Oracle Forms to an MVC Java environment but this was enough to have 20 to 30-year legacy modernization veterans questioning what they were seeing. Probably just as well we didn’t get into our BI for IT front-end or low code application development framework on the back-end…

    Why am I telling you this? Because it does work and it really isn’t that difficult. Morphis was founded in 2013 and has brought significant Computer Science expertise to solving the legacy modernization challenge. Super-bright, young people solving an age old problem.

    Plus there is a cynicism or tiredness among those who have been in the space for a long time. I exclude the partner we’re talking to from that comment, but I met an analyst who looks at the legacy modernization space just a short time after joining Morphis and was struck by his, well, cynicism. If that analyst is advising his clients then he’s unlikely to be presenting modernization solutions as exciting or innovative, but that’s just what Morphis is.

    So what is this platform that has successfully modernized tens of millions of LOC with highlighted case studies such as Ellucian, Miami-Dade County, MV Sistemas and TOTVS?

    It’s a 3 stage process: Analyze, Transform and Develop.

    • Analyze: using Kuscos, our BI for IT solution. What does the legacy application look like. How large, how complex? Redundant/duplicate code? Which modules are most interconnected and, therefore, may represent the most complex to modernize?
    • Transform: now known as “too good to be true” transformation. A single platform that parses in any legacy language and outputs Java or .NET.

    • Develop: a low code application development framework that enables our clients to maintain and enhance their modernized MVC application. This solution is realized as a plugin to Visual Studio (.NET) or Eclipse (Java) and comprises Frames (a technology-agnostic UI definition language, development toolset and runtime engine) and Foundations (the application development framework for database-driven apps).

    To find out how Morphis can support your legacy modernization initiatives in a drama-free, low cost, rapid time to market environment then please contact us.

    Get Immediate Access!
    Send My Report >>

    Wait, Don't Leave
    Empty Handed!

    Don't Miss Out On Our Guide To Which Apps To Modernize, Why, And The Best
    Modernization Approach For Each.
    close-link
    Don't miss out on updates. Subscribe here to receive notifications in your inbox.
    Subscribe
    close-image