Reason #15: Magic xpa Surpasses C# in Interoperability for .NET

20 Reasons to Migrate Magic eDeveloper, uniPaaS and Magic xpa to .NET by Upgrading Rather than Converting

The Magic xpa Application Platform is a particularly strong platform in terms of interoperability of applications. While C# .NET is designed to be proprietary, Magic xpa Application Platform, while .NET based, is designed to deliver greater interoperability. This is one of many reasons why converting a Magic eDeveloper, uniPaaS or Magic xpa application to .NET in C# using a code generator makes no sense. 

Developers looking for fully .NET applications should instead upgrade to Magic xpa.

That’s why Magic xpa provides direct support for technologies like Java, SNMP, MSMQ, JMS, WebSphere MQ, LDAP, Active Directory, Java Script, VB Script, Client Certificates, Dynamic Data Exchange (DDE), IMAP, POP3, etc. All of these internal Magic xpa functions provide direct support for technologies that are otherwise quite difficult or impossible to support with C#.NET. 

The ability of a single programming environment to interface with so many different, unique and tedious environments at a high-level provides tremendous advantages, reduces risk and helps to future-proof your applications. For example, Magic xpa provides direct  Java support including support for Java classes and objects called in a Magic application and Magic applications exposed as Java classes and objects for use by Java programs. 

The idea that C# can handle a converted Magic application is ludicrous. Sometimes developers have no choice but to deal with older technologies like DDE. So even though you might be able to convert your code, without the Magic engine, there is no automatic way for raw C# to handle DDEs.

Let’s look at another simple example like SNMP. Magic xpa supports Simple Network Management Protocol (SNMP) functionality. This lets Magic xpa programs and the Magic xpa engine (the broker and the requester) send SNMP compliant messages to a monitor. It also gives the system administrator control over various Magic xpa modules via an SNMP monitor.

SNMP governs network management and monitors network devices and their functions. Magic xpa is SNMP enabled, so the Network Management Station (NMS), also referred to as an SNMP monitor, can query and manage the Magic xpa broker (including its registered enterprise servers) and the Magic xpa broker can report traps (alarms, failures, or other exceptional events).

Messaging is another great example of Magic’s superior interoperability compared to C#. In distributed applications, two different applications often need to communicate with one another to transfer information. One of the ways to accomplish this is message queuing, which ensures guaranteed delivery.

Message queuing lets applications send messages without waiting for a reply and to continue with other processes. Other applications can receive the messages at their leisure and continue processing according to the data received.

Message queuing is a method by which program instances can exchange data using an interface to a system-managed message queue, which is managed by the operating system. Application programs create message queues, and send and receive messages using an application program interface (API).

There are two main ways to send messages:

Send / Receive – This is used when there are one or more senders who want to send messages to one receiver. Each message is addressed to a specific queue, and the receiver extracts the message from the queue.

Publish / Subscribe – This is used when there are multiple senders (publishers) and many receivers (subscribers). The publisher sends messages to a central location, the topic, which sends the messages to anyone who has subscribed to this specific topic.

Both of these methods provide the user with guaranteed message delivery and are supported out-of-the-box with Magic xpa. Not so with C#.

Every access to the message queue is done using a set of functions, such as open, close, and send. Magic xpa provides a message queuing component with interfaces to three standard messaging queue systems: MSMQ (Microsoft), JMS, and WebSphere MQ (IBM). C# does a passable job only with MSMQ.

For additional information on how an upgrade to Magic xpa is superior to Magic to .NET conversion please convert here.

Reason #7: .NET Done Right

20 Reasons to Migrate Magic eDeveloper, uniPaaS and Magic xpa to .NET by Upgrading Rather than Converting

Reason #7: .NET Done Right

We’re continuing our series of articles for those deciding between uniPaaS migration to .NET  and uniPaaS to C# or ASP. As a number of Magic xpa developers have astutely observed, Magic xpa is .NET done right.

Magic and .NET

With its deployment engine based on the Microsoft .NET Framework, Magic xpa applications qualify as standard .NET applications. This provides developers with access to a wide range of built-in, commercial and third-party .NET services, forms and controls for use in their applications.  Additionally, use of .NET Windows Forms controls give apps a modern, friendly user experience that increases usability. While fully .NET compliant, Magic xpa continues to support native development on Solaris, AIX, Linux, and IBM i server platforms as well.

In addition, the smarter way of developing and deploying applications inherent to Magic xpa, often called ‘the Magic paradigm,’ continues to offer massive advantages to developers. We see this very clearly in the way Magic xpa provides a superior platform for .NET development of data-centric or transaction-oriented business applications when compared to C# or ASP.

With Magic xpa Application Platform you can embed and integrate any .NET control or assembly. You can upgrade the look and feel of your Client-Server or Rich Internet Applications by directly placing new .NET controls as part of the user interface. You can also enhance the functionality of your application by integrating any form of .NET assembly. But you do so without having to write line-by-line code. The assemblies and controls are accessible from the Composite Resource Repository. The repository based nature of development in Magic xpa is vastly superior compared to the difficult and tedious nature of line-by-line text coding in C#. With Magic xpa, data discovery and manipulation is also handled in a repository based way.

Smart Future-Proof Technology

Magic has been enhancing features and helping our customers Outperform the Future for over 30 years and will continue doing so. We provide our long-time customers with simple migration paths to RIA and mobile, and provide an integration platform based on the same technology stack. By migrating your applications to the latest version, our customers can take advantage of new business opportunities quickly, easily and cost-effectively. In Magic xpa you gain:

•          The ability to natively use .NET controls and code as part of an application without losing productivity! This is what our users call .NET done right.
•          Standardization of client look and feel. Magic xpa facilitates a seamless switch from WIN32 to .NET UI and simple support for .NET integration.
•          Magic xpa is stronger and more robust.
•          Magic xpa provides an enhanced, richer more modern user experience
•          With Magic xpa you gain compatibility with the latest databases and operating systems.
•          With Magic xpa, you will find it easier not only to place controls on the forms but also to bind data. 
•          With Magic xpa you gain compatibility with Windows 8 features.
•          And finally, with Magic xpa you have frameset controls that provide you with the ability to create multiple horizontal/ vertical frames and easily transfer data between them within an application.

A Full Solution

Magic customers benefit from Magic’s rich 30-year experience in application development and integration.

You also benefit from our strong community including:

• Extensive professional service expertise and partner network
• Strong developer community including 3000+ ISVs
• Global 24/7 customer support organization
• Strategic alliances and partnerships with mobility and enterprise software vendors including Samsung, SAP, salesforce.com, Oracle JDE, Microsoft, IBM, and more.

For additional information on how an upgrade to Magic xpa is superior to Magic uniPaaS to .NET conversion please convert here. 

Developing for the Web: Merge Technology

Who does the heavy lifting in a Magic xpa application mashup? Is it HTML5, CSS3, JavaScript or the Magic xpa Application Platform? 

To better understand mashups in Magic xpa, we need to remember that Magic has supported merge applications in general and HTML merge specifically for nearly two decades. The basic idea is not new, but all the players have been improved.

As readers of this blog know, Magic xpa Application Platform’s hybrid deployment capability provides support for a wide range of deployment architectures. On the client, these include on-premise (client/server), desktop, Web (HTML5), browser-independent Web 2.0 rich Internet applications (RIA), cloud-enabled software-as-a-service (SaaS), and multiple mobile platforms, including Android, iOS, BlackBerry and Windows, and on the server, Microsoft Windows, Sun Solaris, IBM AIX, Linux and IBM i. All of the various deployment modes are defined in the same application metadata and development project—meaning that application changes can be done once and are automatically propagated in any deployment mode.

Magic xpa’s Studio and ready-made business application engine utilize and interface with all major frameworks, such as Java and .NET, all major databases, and all communication standards and protocols. The question is, with so many options, how do we use Magic xpa to produce HTML5 mashups, or more accurately, HTML merge applications?

HTML Merge-based Applications

Magic xpa lets you design and develop an application for the Internet or Intranet by using: HTML and Java-based interfaces. Any HTML browser on any platform can access a Magic xpa application based on HTML Merge functionality. The Merge technology lets the developer create dynamic Web pages on the server side as a response to HTTP requests.

Concept

Using a set of tokens that are embedded in a regular HTML/XML file, the Magic xpa Application Platform Enterprise Server can merge any application data into the HTML or HTML5 file to produce a dynamic Web page. Magic xpa also uses form models to simplify the inheritance of GUI and other properties across multiple merged Web pages. You can also use any HTML5 editor to create your HTML5 template pages. Magic xpa

Every request for a dynamic Web page activates a corresponding batch program. This program can receive data from the request, such as submit form variables and cookies, process the application data according to the request information, and process the application logic to produce the merged Web page result.

From the Form editor, you can edit the HTML directly, either by zooming on the form from a Merge program, or by clicking on the HTML Editor in a browser-client program. By default, Notepad is the editor that appears.

However, you can choose which editor you want to use. Using an editor designed specifically for HTML, such as Front Page or Dreamweaver, can be useful.

Characteristics

Page Mode Execution

The interaction between the browser and the server is usually manifested in the retrieval of new pages as a result of a request submitted by the previous page.

Compliancy with All Browsers

The developer can choose the HTML/XML version for the application’s Web pages and any other use of client-side scripts and modules. The developer can decide on the level of Web browser compliance by choosing the HTML/XML version and additional modules.

Application Logic

The logic for merging application data into standard HTML files is server-side logic. Any client-side logic required for the application can be integrated with the Magic xpa-generated dynamic Web pages in the form of client-side scripts, such as JavaScript or VB script, and client-side modules, such as ActiveX controls and Java applets.

Controlling the Interaction

The fact that the application logic executed by Magic xpa is server-side only and that the developer determines the client-side logic, including the available hyperlinks, provides full control of the level of interaction between the client and the server.

Context Management

Any request handled by the Enterprise Server is handled independently with no correlation to previous requests submitted by the same application context for a given end user. This means that the application flow context management should be constructed and maintained by the developer.

Considerations

The Merge technology is suited for lightweight interaction between the browser and the server. This technology is designed for applications that mainly receive whole pages on each request.

Network Throughput

The number of interactions between the server and the client is relatively low and the amount of information passed from the browser to the server in every interaction, for example an HTML form’s submitted information, is also low.

However, the result page for every request may be large as the page always returns not just the new processed data but also the entire HTML portions that define the interface and design.

Given the fact that the volume of information passed from the client to the server, i.e. the uploaded data, is usually low, excluding file transfers, there is no need for a large throughput from the client to the server, i.e. the upload rate does not need to be great.

You should try to make your pages as light as possible or make sure that the end user machines have sufficient download capabilities.

Client Machine Requirements

Unless the developer chooses to enhance the pages with various objects, such as ActiveX controls and Java applets, no special requirements are set for the client machine.

Unknown Users

The ability to create applications supported by all browsers lets you freely distribute a Merge-based application with no need to know the end-user machine specifications or count licenses.

Client-side Scripting Skills

If the Web application requires client-side logic, the developers need to acquire knowledge and skills in client-side scripting. Alternatively, the HTML can appear inside the Magic xpa client, such as a Magic mobile client.

So this leads us to the question we started with? Who does the heavy lifting? I think each technology plays its role in a mashup or merge application. Magic xpa does the heavy lifting in terms of the data layer and the logical layer. Familiar web technologies such as the browser, HTML5, CSS3 and JavaScript can be used for client side interactions. 

Quite often, a pure Magic xpa rich client application can replace the need for HTML merge. Increasingly, we are seeing RIA apps on the Internet that allow a single developer to build the client-side and server-side apps without scripting approaches. Whenever this is possible, it is preferred and Magic xpa does all the heavy lifting, leaving HTML5, CSS3 and JavaScript in the dust. 

Welcome to the Magic Application Platform Blog

Welcome to the New Magic Application Platform blog. 

Today, June 11, 2012, Magic launched a rebranding that reflects changes in the company and major developments in its product offering. Magic has experienced significant organic and inorganic growth in the size of its business. New customers and new business units are creating a new Magic that is becoming a formidable force in the IT industry. At the same time, Magic's core application and integration platforms are becoming smarter, more open and more future-proof than ever before. 

As trends like enterprise mobility, integrated IT services, Big Data and cloud computing become key to business strategy at all levels, the Magic application platform and the Magic integration platform have entered center stage as business solutions based on advanced technology. 

What was once called uniPaaS, is now the Magic xpa Application Platform. The emphasis is on the word "Magic." For years Magic's customers have referred to both the company and the application platform as "Magic." This makes sense. It fits the new identity of the company as it enters its fourth decade. The Magic of uniPaaS blog will remain available on the former site but all new Magic programming and IT articles will appear here. Followers of the Magic xpi Integration Platform can continue to find new articles and educational material on the Integrate My JDE blog which covers all aspects of the Magic integration platform.

It is refreshing to see Magic embrace a new identity that returns it to its roots. The company is offering this statement of its brand position: Magic accelerates business performance with smarter, future-proof technology and close customer collaboration. This echoes themes that you've seen in my blogs for several months now.  

As always, I welcome your input and comments on the Magic Application Platform.

Disclaimer: Magic (R) is a registered trademark of Magic Software Enterprises, Ltd. All references to Magic(R),  Magic(R) xpa Application Platform, Magic xpi Integration Platform, Magic University, and other marks both existing now and those that may exist in the future are hereby acknowledged and recognized by reference. All articles appearing on this site are the personal opinion of the author(s) and do not officially represent Magic Software Enterprises, Ltd. or any of its subsidiaries, affiliates or business partners.