The Magic of uniPaaS

The Problem of Communication in Software Change Management

2012-01-23T04:30:00.000-08:00

In our previous discussion of software change management, we focused on analysis and identification problems. This is only one of the problem areas in software change management that have been identified in studies in the field. Other problems that tend to recur related to software change management include communication issues, decision-making challenges, effectiveness roadblocks, traceability issues and problems with tools. As we examine each of these areas, we can see that a number of important issues frequently appear, especially when third-generation languages (3GL) such as Java, RPG, COBOL and various C-languages are involved (C, C#, C++).

In this post, we will review at a high-level how communication issues in software development and software change management can lead to problems. How can we overcome communication issues between developers, business analysts, stakeholders and users to ensure more effective and satisfying outcomes in application development? Are there changes that can be made in the way we approach application development that will tend to reduce the impact and likelihood of errors?

Concurrent or parallel development can cause a need for greater and more frequent communication between developers, business analysts, stakeholders and users. This slows down progress overall and introduces the likelihood of communication errors and misunderstandings. This is especially true when communicating with non-developers. Developers figuratively “speak a different language” and this introduces a greater possibility of misunderstanding. Non-developers and developers can hear the same words and can take away different meanings. In addition, developers and non-developers will tend to attach different contexts, priorities and values to the meaning of communications. The need for greater communication caused by concurrent development, leads to a greater number of possible miscommunications leading to errors and unmet expectations.

Use of shared software components also exacerbates communication issues. Communication is required between more developers because of the shared nature of components. Developer A cannot simply change Component Y without considering the potential effects on development by Developers B, C, and D. This results in the need for distributed decision making on changes to components. Since computer languages are only readable by specialists, explaining the potential ripple effects of component changes can involve the need to communicate with multiple groups of business analysts, stakeholders and users.

A number of strategies can help to overcome these and other communication related issues in software development to help ensure more effective software change management. It is essential to have a communication plan, style and approach for development projects. The use of team development tools for source code control and other issues will tend to help avoid communication errors as well. Whenever it is possible to leverage more advanced development approaches to reduce the number of developers, this will have positive impacts on communications as well. More frequent development cycles by using agile or SCRUM development principles will likely improve communication as well. More frequent prototyping becomes very useful in reducing communication issues. Where human language fails to adequately portray software, prototypes can provide actual or simulated experiences that overcome communication and comprehension barriers. Leveraging repository-based development approaches provides a context for visualizing dependencies that is more effective than scanning a code base, for example. Making use of pre-compiled application platform capabilities will greatly reduce the development effort and minimize communication issues, especially thorny underlying issues in the environment that typically fail to capture the attention of business stakeholders but that can often lead to fundamental differences in judgment of software quality and completeness. If the platform selected allows for the leveraging of .NET based components in client-side development, there can be significantly fewer communication challenges as well.

More effective software change management hinges to a great degree on overcoming communication issues in software development. In our next entry, we will consider the question of effective decision-making or governance as a source of errors from a software change management perspective.

The Problem of Analysis and Identification in Software Change Management

2012-01-18T12:33:00.000-08:00

Studies in the field of Software Change Management have helped IT managers to identify a number of problem areas in software development. Problems related to software change management tend to occur in five areas: analysis and identification related problems, communication issues, decision-making challenges, effectiveness roadblocks, traceability issues and problems with tools. If we examine each of these we can see a number of important issues that frequently crop-up, especially within third-generation languages (3GL).

Today, I’d like to focus on a high-level review of analysis and identification related problems in software change management. How can we identify and analyze problems in our software to best understand and realize where we have errors that require correction. More importantly, how can we change our approach to application development in a way that reduces the impact and likelihood of errors?

Analysis and identification problems can be seen in several areas. First of all, problems with analysis and identification are driven by concurrent and parallel development approaches. The problems occur because with concurrent efforts it becomes more difficult to determine root causes of program errors. This is exacerbated by the fact that standalone testing does not find the problems leading to the error conditions. Solutions can be found by reducing the number of developers, engaging in more frequent cycles (such as with agile development or SCRUM), testing without compiling and ultimately by delegating more basic functions to an application platform in a post-3GL approach.

Another factor driving analysis and identification problems is code optimization. For one thing, optimized code, especially optimized C, C# and C++ code is very difficult to understand. In addition, with optimized code, object oriented development tends to create a ripple effect that is not apparent in typical source. Code optimization issues can be avoided by leveraging pre-optimized code, i.e., avoiding heavy 3GL development projects with more advanced development platforms.

A third factor leading to analysis and identification problems comes from the use of shared software components. Here we see impacts across the code base and ripple effects. These can be avoided through better pre-planning, wise use of inheritance principles and by leveraging a platform rather than resorting to line-by-line coding.

The need for high reliability makes the problem of analysis and identification of the impact of software changes particularly important. It is difficult to predict the impact of changes and at times corrective actions may seem difficult or impossible. Avoid this sense of being overwhelmed by engaging in iterative development and testing. Make use of an application platform to better overcome challenges in the analysis and identification of software change management problems.

Developing Portable Business Apps for the BlackBerry

2011-12-11T15:08:00.001-08:00

In the recent IBM Tech Trends 2011 report, IBM reported that 70% of the more than 4,000 members of its developerWorks community who participated in a recent survey planned to develop mobile apps for Android. Not surprisingly, a mere 19% planned to develop for iOS. It is interesting, however, that 9% have already indicated plans for WebOS. About 35% and 25% plan to develop mobile apps for Windows 7 and BlackBerry OS respectively. A population bias against Apple’s iOS can be expected in the developerWorks community, so no one should try to read the death of Apple into these numbers. If anything, this is a good indication that while most of the non-Apple crowd will be developing for Android, significant numbers will also develop for Windows 7, iOS and BlackBerry OS, and a growing segment has already focused its attention on WebOS.

Magic Software’s uniPaaS Application Platform provides developers with the ability to develop for multiple mobile operating systems and tailor the look and feel for each mobile environment without having to develop using multiple languages.

To get started as a uniPaaS mobile developer, try attending the live webinar Developing Portable Business Apps for the BlackBerry. The webinar will be broadcast live Wednesday, December 14, 2011 11:00 am Pacific Standard Time or may be viewed as an on-demand recording here after that date.

The webinar description states that: “Now you can develop business apps for the BlackBerry that can be easily ported to other mobile platforms as needed in the future. Get just the right level of functionality, interactivity and integration with back-end systems for your BlackBerry users today while preserving your options to deploy to native Android, iPhone or Windows Mobile environments in the future. See a hands-on demonstration and see how the same application platform can deploy cross-platform HTML5 apps as well.”

Building Apps Quickly with uniPaaS and the SQLite Gateway

2011-11-29T16:13:00.001-08:00

Magic Software’s uniPaaS Application Platform includes a SQLlite gateway to support the SQLite database. So does uniPaaS Jet, the free distribution single user version of Magic Software’s uniPaaS application platform.

Those already familiar with SQLite will know that it is a single user, self-contained transactional SQL database engine that does not require a server or any installation or configuration.

The SQLite gateway is integrated in uniPaaS and available with every installation of uniPaaS. SQLite can be thought of as a software library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine. SQLite claims to be the most widely deployed SQL database engine in the world and the source code for SQLite is in the public domain.

uniPaaS Jet supports the SQLite DBMS exclusively. The SQLite database, a single-user database embedded in uniPaaS Jet, comes bundled with the platform, eliminating the need to install it separately.

Once again: SQLite is a single user database and is not intended for handling and manipulating data from multiple, concurrent users. Commercial releases of uniPaaS support multi-user databases such as Microsoft SQL, Oracle, IBM DB2, and any other data source through ODBC.

When working with SQLite in uniPaaS, keep the following in mind:

Table Position	SQLite supports rowid as the table position. The default position is ROWID. Every row of every SQLite table has a 64-bit signed integer key that uniquely identifies the row within its table. This integer is usually called the "rowid". The rowid value can be accessed using a special case-independent name: "rowid". The data for each table in SQLite is stored as a B-Tree structure containing an entry for each table row, using the rowid value as the key. This means that retrieving or sorting records by rowid is fast. Searching for a record with a specific rowid, or for all records with rowids within a specified range is around twice as fast as a similar search made by specifying any other PRIMARY KEY or indexed value. To be clear, a B-tree is a tree data structure that keeps data sorted and allows searches, sequential access, insertions, and deletions to occur rapidly and efficiently.
Get Definition	For SQLite, if the primary key is a single column that auto-increments, the Get Definition utility will not bring the key into the table structure. This is because there is not a separate index using the column. The index internally refers to rowid.
Hints	Hints are not supported and will be disregarded.
Isolation level	Isolation level cannot be changed. Any changes in the DBMS will be disregarded.
Joins	A join is used to combine rows from multiple tables. Inner Joins are the most common type of join. Inner joins return all rows from multiple tables where the join condition is met. Outer Join returns all rows from one table and only those rows from a secondary table where the joined fields are equal (the join condition is met).Inner and Outer joins should be implemented using the same syntax as in the SQL Server.
Transactions	A transactional database is one in which all changes and queries appear to be Atomic, Consistent, Isolated, and Durable (ACID). SQLite implements serializable transactions that are atomic, consistent, isolated, and durable, even if the transaction is interrupted by a program crash, an operating system crash, or a power failure to the computer. In uniPaaS, SQLite physical /deferred transactions are supported.
Array fetching	SQLite does not support array fetching. Therefore, the array size setting will be disregarded and the records will be fetched one record at a time.
Parallel execution	A single uniPaaS engine, or multiple engines on the same machine, may access SQLite via parallel programs. In such a case, only one thread/EXE can open a physical transaction, since the SQLite file is exclusively locked.
APG	Using the Automatic Program Generator (APG) in DSQL SELECT statements will result in the Null Allowed column property being set to Yes.
Identity	Identity should be defined as Type INTEGER PRIMARY KEY. SQLite does not allow more than one INTEGER PRIMARY KEY fields. Identity fields are stored as INT64 data types in SQLite; therefore, you should create a Numeric field to hold 8 bytes of data.

There are two other limitations of SQLite worth noting for the uniPaaS developer. You cannot use the ASCIIChr SQL function which converts a number to a corresponding character in the ASCII character set. You also cannot use the InStr function, which returns a number that represents the first position of a sub-string within an Alpha string or an Alpha expression, or at least you cannot use from within a SQL Where range.

SQLite is just another great addition this year to the Magic of uniPaaS.

Developing Web and Mobile Web Apps with HTML5 and uniPaaS Web Merge

2011-11-23T12:11:00.000-08:00

Developing Web and Mobile Web Apps with HTML5 and uniPaaS Web Merge

Developing for HTML5 with uniPaaS

With the rapid advance of HTML5 as the latest version of the hypertext markup language used by most Web browsers on the Internet, it is exciting to see how seamlessly Magic Software's uniPaaS application platform's merge technology works with this new standard. In uniPaaS, Merge technology lets the developer create dynamic Web pages on the server side as a response to HTTP requests.

HTML5 is the latest specification of HTML or Hyper Text Markup Language. This is the markup language that is used to build web pages. Development of this new version was initiated by the Web Hypertext Application Technology Working Group (WHATWG) and then later carried on by the World Wide Web Consortium (W3C), the organization that establishes standards for web technology.

The Basic Concept of Merge Programming

Using a set of tokens that are embedded in a regular HTML/XML file, the uniPaaS Enterprise Server can merge any application data into the HTML file to produce the dynamic Web page. These HTML files can be HTML 4 standard or the newer HTML5 formats.

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. With HTML5 there are superior options to cookies emerging however. Web Storage is a new HTML5 API offering important benefits over traditional cookies. Although the specification is still in W3C draft status, http://dev.w3.org/html5/webstorage/ all major browsers support it already. This means you can start using the API’s sessionStorage and localStorage objects and enjoy their benefits.

HTML5 subsumes HTML 4, XHTML 1 and DOM2HTML including most especially JavaScript. It provides enhanced levels of multimedia content such as audio and video. and as well as greater interactivity.

Characteristics of uniPaaS Merge Technology

In typical HTML merge applications of the past, the interaction between the browser and the server was usually manifested in the retrieval of new pages as a result of a request submitted by the previous page. With HTML5, the uniPaaS Merge application can process http requests that pass merge data back to more advanced HTML5 capabilities that are part of the included XHTML 1.x standard. A form is a component of a Web page that has form controls, such as text fields, buttons, checkboxes, range controls, or color pickers. A user can interact with such a form, providing data that can then be sent to the server for further processing (e.g. returning the results of a search or calculation). No client-side scripting is needed in many cases with HTML5, though an API is available so that scripts can augment the user experience or use forms for purposes other than submitting data to a server. These advanced capabilities would include new types of form controls such as dates and times, email, url, search, number,range, tel, color.

Form elements and attributes in HTML5
provide a greater degree of semantic mark-up than HTML4 and remove a great deal
of the need for tedious scripting and styling that was required in HTML4. The
forms features in HTML5 provide a better experience for users by making forms
more consistent across different web sites and giving immediate feedback to the
user about data entry.

The developer can still 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. This includes the decision as to whether to incorporate any API extensions to HTML5.

The logic for merging application data into HTML5 files is still server-side logic. Any client-side logic required for the application can be integrated with the uniPaaS-generated dynamic Web pages in the form of client-side scripts contained in HTML5, API extensions, JavaScript or VB script, and client-side modules, such as ActiveX controls and Java applets. uniPaaS provides capabilities such as MGREPEAT and MGIF_NAME that allow you to design your HTML5 pages without knowing how many records will need to be displayed and also to include conditional logic.

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

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 always be constructed and maintained by the developer.

uniPaaS Merge Tokens include:

MG_NAME Replaces the tag with a value provided by the server.

MGREPEAT Begins an area containing an unknown number of repeated values.

MGENDREPEAT Ends the area containng an unknown number of repeated values.

MGIF_NAME Begins an IF Block.

MGELSE Begins an ELSE Block.

MGENDIF Marks the end of an IF or ELSE Block.

MGINCLUDE Allows you to incorporate an entire HTML file.

MGENDINCLUDE Marks the end of an INCLUDE Block.

Other Considerations in Merge Development

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 or interact with HTML5 and API extensions.

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 HTML5 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 HTML5 portions that define the interface and design. Fortunately, HTML5 makes better use of CSS thereby eliminating many formerly common HTML tags such as .

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. With mobile applications, for example, HTML5 pages are almost always lightweight because of the relatively small screen sizes of the devices.

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

The ability to create applications supported by all or most browsers lets you freely distribute a Merge-based application with no need to know the end-user machine specifications. Be aware, however, that API extensions may be supported differently.

If the Web application requires client-side logic, as the developer you will likely need to acquire knowledge and skills in client-side scripting based on the capabilities of HTML5 including JavaScript.

Enterprise Mobile Mashup Delivers Actionable Information

2011-10-24T11:43:00.000-07:00

It’s one thing to be connected via your mobile to relevant information 24/7 and it is quite another to be able to do anything about it. The difference between information and action is the difference between email and apps. On the other hand, action without proper access to information can be dangerous. The solution: enterprise mobile mashups.

As David Akka, Managing Director of Magic Software Enterprises UK points out: “Enterprise Mashup is not something new. Enterprise Mashup is a concept that has been used by many, many enterprises to try to bring information from multiple systems into one coherent view. If you look at the consumer market, for example, estate agents, it’s easy to take information from a property database put it on Google Maps and take information from a police database and put it on the same map in order to present some sort of information to a future purchaser.

“ The whole concept of that actually has started to take off with mobile devices,” says Akka, eagerly pointing out why mobile devices are so important to business today. “Gartner basically predicts that 50% of the workforce by the end of 2013 will use some sort of mobile device. There’s a big argument whether desktops are dead whether mobile devices will overtake them. It’s not really relevant for this point. The point is that on a mobile device the attention span of the user reduces significantly from about 2-3 minutes to about 1 minute.”

Since the mobile user may be paying attention for a shorter period of time, they urgently need accurate data streaming to their device and the ability to act on that information by providing an approval, submitting an order, updating location, etc. Enterprise mobile mashup requires the "round trip capabilities" to pull information from enterprise systems, display information in mobile apps, take action from the mobile device and update the backend systems. And with user preferences and loyalties to a wide variety of devices -- BlackBerry, Android, iPhone and Windows Mobile -- there is a need to provide enterprise mobile mashup via cross-platform, cross-device mobile enterprise application platforms that allow core application logic to be used on any mobile smartphone.

David Akka’s excellent interview on Computing.co.uk not only discusses the possibilities but also demonstrates the smarter approach that Magic Software’s iBOLT Integration Platform and uniPaaS Application Platform take in creating enterprise mobile mashup with backend systems such as SAP, Salesforce, Oracle, PeopleSoft, JD Edwards and so on.

Creating a Branded App with Magic Software's uniPaaS Application Platform: Mastering the Z-Order of Controls

2011-10-15T05:00:00.000-07:00

Creating a Branded App with Magic Software's uniPaaS Application Platform: Mastering the Z-Order of Controls

There is a lot of talk today about the branded app. These are usually mobile apps but sometimes a branded app needs to be a web app or at least an application delivered via the Internet such as a RIA app that floats in a window above the browser -free of all the security and reliability issues that the browser itself imposes. So recently, as the Magic teams from France, Germany, Israel and the Americas headed to Dreamforce ’11 (#DF11) I found myself wanting to keep track of all the sessions we would be participating in at the conference. Unfortunately, the Dreamforce Chatter application didn't have that functionality. It seemed to me that I ought to be able to add meetings and appointments to the My Calendar section of the Dreamforce app, but alas, I could only add the sessions for which I was eligible to register. So with a little creative daydreaming, I started to wonder, how I might create an event calendar application in uniPaaS and make it look like a branded app for Dreamforce. That exercise got me thinking about the Z-order of controls.

The uniPaaS Dot Net Tutorial provided the perfect sample program in Events .NET Calendar. But I wanted to make it look like a Dreamforce application. So with a little help from my browser, Photoshop and an understanding of the Z-Order of Controls in uniPaaS, I was able to get my sample application to look just the way I wanted. I wanted a branded app.

From the uniPaaS Jet Dot Net Tutorial, I clicked on the Programs Repository in the Navigation Pane in the upper right and then zoomed (F5) on the Events .NET Calendar. This opens the program in the Studio. I wanted to play with the look of the program because the Control itself was kind of a drab gray typical Windows control.

The first step was to find a couple of images that I wanted to use. My preferred graphic image editor is PhotoShop. I pasted a couple of images into PhotoShop and saved them as JPEG files.

Back in uniPaaS Studio, I selected the Forms tab and zoomed (F5) on the second form which was also named Events .NET Calendar. On the uniPaaS Studio Forms Control Pane, I selected the Image icon and then clicked on the approximate position where I wanted the upper left corner to appear.

Some tweaking of the image position was needed. So the precise X, Y coordinate can be set for the image’s Navigation Control Properties.

The Z-Order of controls in a form is the depth of the controls as you insert them. The Z-Order becomes particularly important when you superimpose controls on top of one another.

Here is an example where images and controls are partially overlayed. You will note that one of the two women in the photographic image is not visible. Why? Because the Z-order of the entire image is essentially underneath the .NET control that contains the calendar.

uniPaaS recognizes two groups of controls with regards to Z-Order:

Group I	Group II
Push buttons Check boxes Radio buttons Sliders Combo boxes List boxes OLEs RTFs Tree Control Subforms Browser Control	Images Tabs Static controls Edit controls Lines Groups

You can rearrange the Z-Order within the two groups, but not between them. uniPaaS automatically arranges the Z-Order between Group I and Group II controls. For example, if you were to place an Edit control on top of a Push Button control, the Z-Order would arrange the controls so the Push Button control would be placed in front. You cannot bring a control from the second group in front of a control from the first group. You use theArrange context menu or the Command palette to display or change the Z-Order of controls on a form.

To adjust the Z-order you have to make sure Automatic Z-Order is not selected on the Command palette. That’s the icon shown here. You should also learn how to use the other icons to Bring Forward One Level, Send Back One Level, Bring to the Front, Send to the Back and Display the Z-order.

So with very little effort, a ho-hum control can be enhanced with the use of images and become a branded app. When I deployed my Magic Software uniPaaS Application Platform RIA program in a Window over the Dreamforce web page the result was very pleasing from an aesthetic standpoint.

Learning to Program with uniPaaS

2011-10-14T08:04:00.000-07:00

Whether you are a beginning programmer or an experienced hack, learning to program with the Magic Software uniPaaS Application Platform is pretty exciting because of the way the application platform allows you to focus on the application design and business logic rather than on the underlying architecture and housekeeping tasks normally associated with programming. With uniPaaS you can create anything from mobile apps to cloud applications and of course standard client-server software as well.

Magic Software has provided about 1000 sample programs with the application platform to help illustrate all of the capabilities of the platform and make it easier for you to create your own programs.

The sample programs included with uniPaaS are installed in the SampleProjects folder.

Rich Internet Demo: Many of you have seen the Magic Software Rich Internet Demo that is comprised of several applications running in rich client mode. This means they are browser-free, require no plug-in and yet run via the Internet with full connectivity to the server. You can use this platform to create your own cloud or on-premise applications and the RIA demo helps illustrate what’s possible in very basic easy-to-understand samples. The project containing all of the sample programs of the live RIA demo is available at http://riademo.magicsoftware.com and the mobile RIA demo examples can be found at http://riademo.magicsoftware.com/mobile

Online Samples: A set of online (client/server) examples for multiple client/server ‘how to’ scenarios that are described in the book: Mastering uniPaaS.

Rich Internet Samples: A set of Rich Internet examples for many rich client ‘how to’ scenarios that are described in the book: Mastering uniPaaS.

Mobile Web Samples: Web templates based on HTML Merge technology for mobile devices.

.NET Tutorial: A short tutorial with examples explaining how to use .NET in uniPaaS.

All the projects are available with their source code, so you can use them in your applications.

In addition, to the samples you also have access to the complete resources of Magic Software University. You can also easily download a self-paced course for creating business applications. And for those adventurous programmers who are looking for an excuse to come to “the OC” in sunny California this November we offer uniPaaS courses in our classroom in Laguna Hills, California. Upcoming courses include:

07-9 Nov, 2011 Migration from eDeveloper V9.4 to uniPaaS Open Client

10 Nov, 2011 Insider's Guide to Advanced RIA Development with uniPaaS

11 Nov, 2011 .NET Components Unleashed with uniPaaS Applications

A Smarter Way to Do Asynchronous Programming

2011-10-13T08:45:00.000-07:00

The cover of MSDN Magazine this month carries the main headline: “Asynchronous programming.” Inside you will find three articles about these new proposed features that will make it easier to write code that will help to create efficiencies in Visual Studio applications for asynchronous programming.

The entire article is about how it will be possible in the future to write code that does what the Magic application platform has been doing automatically for its programmers for more than 10 years. Visual Basic and C# don’t have these capabilities yet, but they will in the future the articles proclaim, but it will still require the developer to add special code and the creators of these languages are so far away from a solution that they are using the magazine to solicit feedback on the idea. Wow.

I think it is easy for those of us familiar with uniPaaS seamless efficiency through multithreaded concurrent architecture to forget that other developers must tell their programs how to handle concurrency of task execution. I remember being very impressed with the initial analogy used to explain the Magic engine and the Magic broker: the example used was that of a restaurant with many waiters and a short order cook or cooks who were working on many meals in parallel, breaking down the meal preparation into discrete steps and jumping back and forth between tasks.

At Magic Software, we talk a lot about how our advantage is a metadata driven architecture, but when you read the articles in this month’s MSDN Magazine it crystallizes some of the low-level nonsense that other developers put up with every single day without realizing that it Is a complete waste of time for them to be creating business applications in those languages (and don’t get me wrong, Java is no better). The sad thing for these developers is that they have to add lots of instructions to their code to tell the program how to process tasks concurrently. Really, in 2011 programmer drones are paid six figure salaries and still writing the same code concepts over and over again?

Thankfully, there is a smarter way to do asynchronous programming and achieve highly efficient applications without giving it a second thought. That approach is found in Magic Software’s uniPaaS application platform. Even after Microsoft finishes its "enhancements" to C# and Visual Basic (tough luck if you're using a different Microsoft language) you will still have to manually add "await" instructions to your code. And since there was no thought put into forward-migration and everyone handled concurrency differently, you will have to manually strip out all the old concurrency code. Yuck! The three articles were nice, very enlightening as to the tedium on the other side of the fence, but as for me: here’s three cheers for uniPaaS!

To see a sample business application running in Magic Software's uniPaaS application platform see the RIA demo here. To read more about Magic Software's smarter application platform, see the information on the company website.

Overcoming the top three mobile app design & development constraints

2011-09-28T19:02:00.000-07:00

Mobile app developers have to be the ninjas of programming because they have to get in, get the job done, and get out without consuming a lot of resources.

There are two ways to overcome the common mobile app design and development constraints: the first is to design around them using brute force, not very ninja like, and the second is to design more efficiently based on a mobile enterprise application platform like uniPaaS. Let’s consider some of the common constraints and how you can do both: design around them and design more efficiently by using a true mobile app development paradigm for enterprise and (dare I say it?) even consumer apps. My comments here will be primarily based on developing for BlackBerry mobile devices, but he same uniPaaS application platform and the general efficient principles of design will also apply to Android, Apple iOS and Windows smartphone development.

Limited Memory. Creating an application that requires less memory will improve the user experience by improving response times and reducing the likelihood of errors. Unfortunately, memory management in Java and Objective-C is extremely time consuming for developers. So regardless of which mobile enterprise application platform (MEAP) you are using you will want to design efficiently. If a field isn’t vital, eliminate it from the app or relegate it to optional views and call for the data only when needed. By using the uniPaaS application platform, you can leverage server side resources to deliver just the data you need when you need it and the best thing is, you don’t have to write any of the code for the underlying architecture or the client. You simply leverage metadata to control your app and the Magic Engine does the rest. To be clear, you avoid the need to program directly in Java or Objective-C altogether. It isn't like Magic, it is Magic!

Limited Battery Life. Battery life has less to do with the efficiency of data usage (although that is clearly one factor) and has more to do with efficient use of the radio. Apps that constantly poll the server for new data, for example, will heighten battery use and frustrate users when the device is drained. In traditional enterprise apps, polling the server across a LAN is a cheap resource and so developers tend not to give it much thought. But in a mobile app it is an even more important issue. Fortunately, the uniPaaS BlackBerry client is very efficient in its use of the radio and you don’t have to manage memory manually at all. This greatly reduces development time and ensures application efficiency and performance.

Limited Screen Size.

The BlackBerry OS supports a simple stacked window model and as with all smartphones, the screen is quite limited in size compared to desktop applications. Developers need to focus on the users’ task at hand, literally. Do this by displaying only the immediately relevant info and any directly related tasks. Keep it simple and yet functional.

With a BlackBerry, each application can open multiple windows, but each new window is stacked on top of previous windows and is inherently modal. As there is no mouse pointer, windows cannot be manipulated (moved or resized) by the end user. When an application is run, its main window (and subsequent stacked windows) occupies the entire device screen. How does one navigate then? The context menu is often the best way. The BlackBerry context menu is an important and central user interaction tool. Since the screen size is relatively small, it is common to perform most tasks using the context menu, instead of “wasting” screen space on buttons and on-screen menus.

Unlike most other smartphones, most BlackBerry devices are optimized for keyboard navigation and input. Typically, the trackpad is used to navigate between fields on the form, while the Fire action is used to select values and perform actions. Unlike a desktop keyboard, there is no TAB key so there is no standard key to move to the Next Field or the Previous Field. All navigation between fields and inside a field (i.e an edit control), is done using the trackpad directional actions.

Other Considerations. These top three constraints aren’t the only ones you need to consider, but they are the most important. You should also consider the impact of the longer latency caused by slower mobile bandwidths (compared to LANs) and the fact that smartphones have less raw processor power than desktop clients. All of these issues are mitigated by use of Magic Software’s mobile application platform. Happy developing! For additional information, please contact the Magic Software Enterprises branch near you.

The Magic Mobile Cloud Daily

2011-09-28T18:22:00.000-07:00

Please take a look at the Magic Mobile Cloud Daily. Posts from my friends and colleagues will frequently appear in this daily publication. Once you view the publication, be sure to click on the subscribe button so you an be notified of new issues. Enjoy!

If Chuck Norris Were A Programmer

2011-09-14T17:26:00.000-07:00

Top Ten “If Chuck Norris Were A Programmer” Jokes

10. If Chuck Norris were a programmer, memory would be afraid to take a leak.

9. If Chuck Norris were a programmer, President Obama would be doing his garbage collection.

8. If Chuck Norris were a programmer, the food chain would collapse because he would kill every bug on the planet.

7. If Chuck Norris were a programmer, unstructured data would become structured. With Chuck around, nobody ever gets out of line.

6. If Chuck Norris were a programmer, application security wouldn’t even be an issue.

5. If Chuck Norris were a programmer, all his programs would be strongly typed.

4. If Chuck Norris were a programmer, none of his functions would have arguments.

3. If Chuck Norris were a programmer, his first program wouldn’t be ‘Hello World’ it would be ‘Goodbye Underworld.’

2. If Chuck Norris were a programmer, there would be no exception handling, because there would be no exceptions ever.

… and the Number One “If Chuck Norris Were A Programmer” Joke:

1. If Chuck Norris were a programmer, all his applications would be perfectly metadata-driven. After all, they would be developed on a Magic application platform!

A Trip to the .NET Forms Library with uniPaaS 2.0

2011-09-13T16:28:00.000-07:00

With the release of uniPaaS 2.0, the Magic Application Platform now supports the use of the Windows .NET forms library. These capabilities are delivered by .NET within “classes” that are a part of what is known as the System.Windows.Forms namespace.

Beginning with uniPaaS 2.0, the use of the .NET Forms library within a uniPaaS application is supported in both uniPaaS online (client server) and rich client tasks. After you begin a new task, you must define your .NET object in a new variable by creating a virtual variable in the Dataview Tab of the uniPaaS task. You select the .NET object type either by typing the name or using the uniPaaS selection lists to find the .NET object you want to use.

Developing with the Windows .NET forms library is much easier on the uniPaaS .NET application platform than it is in simple 3GL .NET coding languages such as C#, C++, JScript or VB.NET. uniPaaS 2.0 provides a metadata driven paradigm for application development that allows you to easily incorporate managed code from the .NET forms library along with so-called “unmanaged functionality.” This is true because the uniPaaS 2.x runtime engine is an extension of the uniPaaS 1.x runtime engine. A new .NET front-end wraps the existing C++ engine, thus enabling both .NET and unmanaged functionality in a single runtime engine. The ease-of-use comes into play in several ways:

When you want to use .NET forms capabilities, you can. It is not mandatory. Very rich applications can be designed using the core GUI capabilities within uniPaaS.
Adding .NET managed code is simplified because your overall application leverages the benefits of the uniPaaS metadata-driven platform. Low-level programming is never required.
uniPaaS’ tab and table driven interface allows you to avoid complex line-by-line scripting and coding. uniPaaS takes care of the typical programmer “housekeeping chores” so that there is less effort than normally expected to create a program.

Let’s review the seven main class categories in the Windows .NET form library:

Control, User Control and Form classes. The Control class constitutes the majority of classes available in the System.Windows.Forms namespace. Controls are key to visibility. In other words, a control class is sued to provide the base functionality for all program controls that are displayed on a form in your application. You can think of a form as a window within your application such as a dialog box, modeless windows, Multiple Document Interface (MDI) client and parent windows.

Menu and Toolbar classes. The library also includes a category of classes for building custom toolbars and menus with your desired look and feel. ToolStrip is used for creating toolbars. MenuStrip is used for creating menu bars. ContextMenuStrip is used to create context menus. And StatusStrip can be used to create status bars.

Standard GUI Control classes. The Windows forms library included a number of mainstream controls for input (such as TextBox and ComboBox) display of data (such as Label and ListView) and firing of commands (such as Button).

Layout classes. The layout classes in Windows Forms help control the layout of controls on a display surface, such as a form or control. For example, the FlowLayoutPanel lays out all the controls it contains in a series, and the TableLayoutPanel provides a control for laying out data in a fixed grid. More sophisticated layouts can be managed through the SplitContainer class which is a control that divides your display area into adjustable parts.

Data and Data Binding classes. You can also use Windows Forms to create the interfaces for binding to data sources such as databases, XML and flat files. The DataGridView is a sophisticated data control that allows for custom tables displaying information with specific cell, row, column, and border properties. Also, the BindingNavigator and BindingSource controls allow you to develop interfaces that navigate and work with data on a form in a standard way.

Helpful classes. It is possible to use a number of other helpful classes within the Windows Forms namespace that aid in the display of application related information in your application. Certain classes, provide Windows standard ways of displaying a ToolTip or an error (ErrorProvider). And the Help and HelpProvider classes are useful for displaying relevant Help information to a user of your applications.

Traditional Dialog Boxes. The final category of Windows Forms classes that we’d like to discuss are common dialog boxes. Dialog boxes give your application a consistent look and feel for common and repetitive functionality such as opening or saving a file, manipulating text properties such as font, size or color, printing or any of a number of other common processes within your application. For example, the OpenFileDialog and SaveFileDialog classes display dialog boxes for opening and saving files by users. The FontDialog class provides a user dialog box set Font properties used in a particular aspect of your application. The PageSetupDialog, PrintPreviewDialog, and PrintDialog classes display well-known and easily understood functionality in a standardized way as well. In addition to the common dialog boxes, a MessageBox class is also available to create a simple box to display and retrieve data from the user.

Conclusion. In addition to all the standard classes within the System.Windows.Forms namespace, there are of course a number of very interesting third party controls libraries that are worth exploring when you’re looking for that “something extra” or special pizzazz in your user interface. The trick is finding the right balance between uniPaaS, standard .NET and third-party controls within your application. That’s all for this trip to the library.

The Benefits of Metadata Driven Development

2011-09-08T02:59:00.000-07:00

Eyal Pfeifel, Magic Software’s Chief Technology Officer, recently sat down to discuss metadata driven development. In the video, he provides a useful definition of metadata driven development: “Metadata driven development means developers build business applications using metadata and not using code. Metadata is a high level definition of business objects like forms, dialogs, validations and other things that are part of a business process that build a business application.”

Eyal Pfeifel contrasts metadata driven development with traditional coding or manual programming. “Unlike code which is tied to a specific platform or operating system, metadata is a high level definition and theoretically can run on any platform or operating system. Given that you have the appropriate runtime engine, you can build an application built using metadata on any kind of a device, server or client,” says Pfeifel.

As Chief Technology Officer for Magic Software, Pfeifel certainly knows what he is talking about when it comes to traditional programming languages. Magic Software uses these more difficult third-generation languages (3GL’s) to create the metadata driven platform that is integral to Magic Software’s higher level and more intuitive application platforms. For this reason, he is keen to recognize the benefits of the metadata paradigm over traditional programming. “One of the main benefits of working with a metadata driven development paradigm is that since metadata objects are high level business objects it is possible to build a complete business application in a much shorter time than it would take when using code. And the same business logic that you can construct one time very easily is relevant for multiple platform and operating systems like desktops, servers and even mobile devices.”

As Magic Software introduces its impressively expanding capabilities as a mobile enterprise application platform provider, Pfeifel has found himself commenting a lot recently on one of his favorite subjects: mobile application development. “Using a metadata driven platform it is very easy to extend an enterprise application that originally started on a desktop or on a server into mobile devices because once you have the runtime engine running on a mobile device, it can theoretically run any type of application that you built on a desktop,” Says Pfeifel. “And you can extend your business processes into a mobile device without needing to rewrite the application from scratch and with minimal adjustments just to cater for the smaller screen size or different form factor of the mobile device.”

Magic Software has a strong reputation for providing expertise that can future-proof your application development investments. As one can see by sitting down with Eyal Pfeifel, Magic Software's future-proof expertise is based on extensive customer feedback, strong R&D investment and the mindset to continually think ahead. To learn more about the Magic application platform, visit magicsoftware.com.

Will Google’s Acquisition of Motorola Really Solve The Mobile Device Fragmentation Problem for Developers?

2011-08-22T13:03:00.000-07:00

Some people seem to think so. A recent article in SD Times quoted Gartner researcher Carolina Milanesi as stating that the acquisition could partially solve the developer's dilemma over the mobile device fragmentation issue on Android devices from various manufacturers. But this optimism requires a narrow view of fragmentation as it relates to devices deploying Android only. And it also requires speculation that Motorola will not continue to support some proprietary layers running over the generic Android OS.

More significantly, however, such optimism completely ignores the fragmentation between mobile operating systems. Google’s acquisition does nothing to help developers who want to develop for both Android and iPhone and Windows and BlackBerry. Google’s acquisition does nothing to bridge this gap. If anything, it tends to guarantee that mobile operating system fragmentation will continue.

The value of a Mobile Enterprise Application Platform’s ability to create applications for multiple mobile devices and mobile operating systems remains strong. As developers find users of a variety of devices needing access to applications, they will need straightforward development solutions that allow them to develop applications targeted to each device without needing to reprogram everything from scratch.

The uniPaaS 2.0 Mobile Enterprise Application Platform not only provides an IDE for developing the client applications, it also provides a robust platform for developing and executing the server side application logic. Known for its scalability across IT infrastructure ranging from small businesses servers to massive enterprise deployments, uniPaaS 2.0 can handle very large scale transaction, communication and transport processing.

I believe the real benefit for developers in the Google acquisition will emerge as Google is forced to take its own medicine. The practical challenges of developing an operating system that can take advantage of the latest advancements in the device hardware should result in a more coherent evolution of the Android OS. Even competitors to Motorola should find future Android OS versions to be more market ready without as much need for tweaking and layering. Despite this, the really large market fragments will persist: iOS, Android, Windows Mobile and BlackBerry OS will persist and developers will need to decide on their best strategy to maximize their market reach.

The New Magic Software Application Platform and the .NET Framework: The Best of Both Worlds

2011-08-02T10:15:00.000-07:00

The new Magic Software Application Platform, uniPaaS 2.0, implements a new .NET deployment engine, which turns any existing uniPaaS application into a native .NET application. According to Microsoft, the .NET framework is comprised of a Common Language Runtime (CLR) that provides an abstraction layer over the operating system; Base Class Libraries that deliver pre-built code for common low-level programming tasks; and development frameworks and technologies offering reusable, customizable solutions for larger programming tasks. The new uniPaaS 2.0 engine uses the Windows Forms .NET library as the GUI front-end for applications. To be clear, Windows Forms is the name given by Microsoft to the graphical application programming interface (API) included in the Microsoft .NET Framework. Windows Forms provide access to native Microsoft Windows interface elements by wrapping the existing Windows API in managed code. uniPaaS 2.0 seamlessly leverages this capability to provide superb RIA and client/server GUI capabilities. In fact, uniPaaS 2.0 provides full integration with the Microsoft .NET framework to significantly enhance application design, functionality, and overall user experience. uniPaaS 2.0 also offers new RIA-related enhancements.

With uniPaaS 2.0, Magic Software will soon be offering its first Mobile Enterprise Application Platform with support for devices running the BlackBerry OS or Windows Mobile 6.5 as a client deployment platform immediately and both iPhone and Android in the near future .

In a press release last month, Magic Software Enterprises (NASDAQ:MGIC) included a quote from a Microsoft product manager regarding use of Magic Software’s integration platform for SharePoint integration. With the release of uniPaaS 2.0, it becomes clear that Magic Software is now even more closely aligned to leverage underlying Microsoft Windows and .NET framework technologies.

In fact, one might even say that uniPaaS 2.0 is a .NET programming language (just as one might also say that it is an IBM i programming language or an AIX programming language or a Linux programming language). So the difference is that last week you could only really say of uniPaaS 1.9 client/server programming was that it was a Windows programming language. Now, one can see Magic’s application platform as fully supporting and being fully supported by the .NET framework. In this sense it can sit alongside Visual Basic.NET and other .NET programming languages for Windows servers and clients just as it can sit alongside RPG and COBOL for creating IBM i server applications, etc.

The good news for enterprise IT departments that have adopted .NET application development as an enterprise standard is that uniPaaS 2.0 now meets (and even exceeds) the requirements for being a .NET framework application platform. This is good news because unlike existing .NET languages, uniPaaS supercharges .NET in a way that no other approach can.

How does Magic Software’s uniPaaS 2.0 application platform turbocharge the development and deployment of business applications? First, uniPaaS accelerates the development on .NET framework application by providing straightforward and streamlined development methodology that further abstracts the development process without sacrificing control. Then, it stabilizes the performance and operational integrity of applications by leveraging our proven, highly scalable application platform technologies.

This release is just another example of Magic Software's long history of providing solutions that protect your applications from the underlying changes in operating system , client, server and other technologies. By future-proofing your business applications with the use of the Magic Software application platform, you are able to outperform your competition and surpass all expectations for your ability to adapt to whatever changes the future may bring. To learn more, please access these resources.

uniPaaS 2.0 is Now Shipping

2011-08-01T13:18:00.000-07:00

Magic Software has today issued a new major release of our application platform. Building on the success of previous releases, uniPaaS 2.0 provides key enhancements for improved client server applications, enhanced RIA development and standardization.

uniPaaS 2.0 builds on key benefits that you expect from Magic Software by providing a future-proof, metadata-driven application platform that combines powerful studio resources for development with standardized .NET based rich front-ends for highly interactive user experiences across a variety of clients.

Extensive functionality previously not supported by uniPaaS is now fully embedded so that developers can leverage industry-standard controls in existing and new applications. uniPaaS 2.0 provides a superb foundation for future development across multiple mobile device environments, RIA, client-server and cloud-based deployments.

The new client/server runtime uses controls from the Windows Forms .NET library to provide a highly interactive and graphically appealing front end to users. Both the look and feel of the applications and the usability are improved as applications take on a more modern style. Because the uniPaaS client is now based on a .NET layer it is easy for the developer to call any .NET class including third-party libraries. You can take advantage of many of these improvements by migrating your application to uniPaaS 2.0 either through the effort of your own development team or by using Magic Professional Services to assist in your modernization effort for your applications. Our consultants have extensive experience advising and implementing enhanced user interfaces based on .NET controls and third-party libraries.

We will discuss specific enhancements in a future entry. Let the era of uniPaaS 2.0 begin!

Take A Load Off: Use RESTful Web Services in uniPaaS

2011-06-15T13:41:00.000-07:00

Take A Load Off: Use RESTful Web Services in uniPaaS

We’re pretty good at keeping "well-guarded" secrets at Magic Software. Sometimes we even release useful new features that few people know about. We made a lot of fanfare when we started supporting Web Services based on the SOAP protocol. In fact, I think I wrote the press release back in January 2002.

Here we are nearly 10 years later and uniPaaS now supports REST (Representational State Transfer) approaches to Web Services and few of us paid close attention when this feature emerged in the product with the release of uniPaaS 1.9e. But it is worth paying very close attention because RESTful Web Services can be accomplished without the complexity and overhead of SOAP Web Services.

REST isn’t something new at all. In fact, it is the way the Web has worked all along but with some rules added to help everyone get along.

What are RESTful web services?

Baiscally, a RESTful web service is a simple approach to web services implemented using HTTP and based on the architectural principles of REST. A RESTful Web Service has three resources defined:

the URL address for the web service (you may call it a URI if you want, it is basically the same thing). The URL is the equivalent of a noun.
the supported Internet media data type of the web service.
the set of HTTP operations supported by the web service. Think of this as the verb.

The following table shows how the HTTP methods are typically used to implement a web service.

Unlike Web Services based on SOAP, there is no industry protocol for RESTful web services. In this sense, it is akin to a concept like Service Oriented Architecture (SOA) where a number of different approaches and protocols can be used to accomplish the objectives of the architecture. RESTful Web Services are based upon established W3C and OASIS protocols such as HTTP, URL, XML, etc. The REST architectural style is based on the idea that a client and server are interacting in a stateless manner with cached data via a uniform interface.HTTP 1.1 was designed to conform to REST. Unlike SOAP and XML-RPC, REST does not really require a new message format. Nevertheless, XML is the most popular type of REST message format. When you use XML, it becomes easier to represent the information resource in a variety of ways using XSLT and Cascading Style Sheets (CSS).

In uniPaaS 1.9e, we improved upon the ability of uniPaaS developers to employ RESTful Web Services by adding a new function: HTTPCall. This function may be used with a proxy server and supports SSL\TLS with the client certificate password protected and both basic and digest authentication schemas.

HTTPCall runs an HTTP request and returns the results. You can consume REST services by using HTTPCall with any and all verbs. This function can be used instead of the HTTPGet and HTTPPost functions, thereby simplifying implementation of RESTful Web Services in uniPaaS. The syntax within uniPaaS for the use of HTTPCall is as follows:
	HTTPCall (verb, service URL, message, [header1], [header2], …)
	The “verb” is a string indicating the method. The options include GET, POST, PUT, DELETE, and HEAD. You can GET a list or a specific member of a collection. POST is like an append operation in that it adds a member to a collection. PUT replaces an entire collection or a specified member of the collection. DELETE erases the entire collection or a specific member of the collection. HEAD is a header that provides additional header information. The “service URL” is the string that represents the HTTP address where you will retrieve the HTTP request. The HTTPCall function can easily pass a user name and password to the service URL for a secure, rights-based approach to Web Services. For example, when a uniPaaS client is accessing a web server that requires a user name and password, the URL should be HTTP://User:Password@[URL]. uniPaaS will also support secret names by following this approach: HTTP://%user_secretname%:%pass_secretname%@[URL] Obviously, the “message” is a string with the text of the message. There is no limitation on the message content. Messages are self-descriptive and stateless. The use of “headers” is strictly optional and you may include as many as needed. Each header may contain a string that provides additional header information as requested.
	As one might expect, the HTTPCall returns a BLOB containing whatever information results from the HTTP request. If the function fails to make the connection, a blank value is returned. You can get the response headers using the HTTPLastHeader function. Magic Software provides both Online and Rich Client sample programs that detail the use of the HTTPCall function. Look for sample programs EL23 and REL23 to get an idea of how this function can be implemented. One of the traditional disadvantages of REST is that it doesn’t do well with complex data architectures such as those of relational databases. In this regard, using uniPaaS allows you to bridge the gap between REST and traditional databases. With uniPaaS, information is exchanged and represented using RESTful Web Services while at the same time you can store enterprise data in industry standard databases. REST advocates will simply say databases are too complex and should change to conform to the way the Web works. With uniPaaS, you avoid that argument altogether. It just works.

Mobile Enterprise Application Platform: Any Time

2011-06-06T11:40:00.000-07:00

Ten Key Questions to Help Compare MEAP Vendors

Comparing mobile enterprise application platforms (MEAPs) can be challenging. Quite often those that are seeking a MEAP solution do so precisely because they do not want to invest in developing in-house expertise in all of the programming languages and environments required to provide native client solutions for major mobile device environments such as BlackBerry, iPhone, Android and Windows. The IT departments ability to anticipate the challenges of each target device environment is often limited due to lack of familiarity with the differences in all these environments.

To complicate matters more, MEAP vendors are rarely what they appear to be. It is first of all necessary to try to separate out current capabilities from future plans in the vendor roadmap. One must then ask, what is the vendor history in living up to the promises in their roadmap?

Even once you have all this sorted out and have separated out marketing hype from actual platform capabilities, the task of making comparisons gets tricky. Is device management a necessary part of the evaluation, or should we consider that a separate category just as we consider development tools and IT operations software as separate systems in the data center? Evaluators need to carefully consider their own rollout plans versus the vendors plan for device support.

More important than any of these tangled issues, however, is the question of productivity. The reason for adopting a MEAP is to reduce effort. In order to live up to the need to develop and deploy mobile apps at anytime and anywhere, you need a MEAP that is truly metadata based, employs fully native clients, and has seamless capability to develop and maintain enterprise data center, enterprise cloud and enterprise mobile apps without duplicate programming efforts.

Here are a few key questions to ask a MEAP vendor?

1. Are native coding skills required to complete projects or make changes? Some MEAP vendors surprisingly do not complete the process of creating the mobile app for the target device. Manual programming and tweaking is required.

2. Will we need to use the native debugger to test our applications? If the MEAP forces you to debug their deployment capabilities on a target device, then you that means you are likely to be required to write code to fix any problems you find.

3. Can my MEAP platform also create desktop, client server and web applications? Some MEAPs are mobile only and have little or no capabilities for supporting other types of applications. This lack of support means duplicate coding for those environments.

4. Does the MEAP platform allow me to control the look and feel of the application so that I can develop with a native look and feel for each device? Will BlackBerry apps look like other BlackBerry apps? Will an iPhone app look and feel like an iPhone app? etc.

5. Does the MEAP platform vendor have a solid track record of back-end integration? Do they have a complete set of integration tools to allow you to integrate enterprise IT systems, data and processes with your MEAP platform? Integration to backend systems is a crucial component of providing B2E, B2B, and B2C applications. Without a straightforward solution for integration, you may end up spending months of unnecessary development time trying to integrate your mobile apps to existing enterprise systems.

6. Is the solution multilingual and can the vendor provide multilingual support? If you need a global solution, some vendors have limited reach in North America but not beyond.

7. How long have you been in business? Too many vendors are in startup mode with no guarantee that they will stick around.

8. Will you provide financial statements showing your revenues, profitability, cash on hand and debt position? If a vendor is unwilling to provide financial statements, then you are at significant risk that you may be dealing with a vendor that is on the brink of imminent financial failure.

9. Does the MEAP vendor have a parent company whose objectives are different from those of the independent software vendor that it acquired? If the parent company acquired the MEAP platform to serve the needs of its larger client base, will that be at cross-purposes to your needs?

10. Does the MEAP vendor have a coherent strategy for enterprise systems, mobile apps and the cloud? Can the vendor ensure that all of these solutions can be based on the same service-oriented architecture (SOA)? Is the platform capable of compositing existing application logic from Java, .NET, COBOL, RPG and other environments? A good MEAP platform will be capable of leveraging all that you have today and have a coherent strategy for deploying solutions in all of the environments that you need to be in tomorrow. A vendor that can future-proof your efforts will ultimately be the smart choice for development of mobile apps.

Once you have a satisfactory sense of what your vendor can offer, the question of how it is licensed and priced is appropriate. Some vendors adhere strictly to a per user pricing strategy. Others offer a per server pricing model. Some offer both or a hybrid. If you are developing a B2C enterprise mobile app, then per user charges are unappealing. But if you have a fairly small target B2E or B2B audience, then hefty per server pricing may be disadvantageous. In the final analysis, you will need a vendor that is willing to work with you to assure complete satisfaction and success. Evaluate vendor technical support, training and professional services. All these things combine to make the selection of a MEAP platform a difficult decision. But if you know the questions to ask, you are on the right track. To see a video announcing the Magic Software Mobile Enterprise Application Platform (MEAP), click here.

Mobile Enterprise Application Platform: Any Device…

2011-05-14T09:46:00.001-07:00

When choosing a mobile enterprise application platform, the ability to deploy to any device is an important consideration. Even if you only need to deploy to one or two types of devices currently (such as BlackBerry or Windows Mobile), you'll want to choose a platform that can give you the opportunity to deploy on Android and the iPhone in the future. But the question of "any device" goes much deeper than that.

A mobile enterprise application platform must support the native user interface of each device. In other words, a BlackBerry application should look like a BlackBerry application and an application for the iPhone should look like an iPhone application. Many of the solutions being used today such as Citrix and Terminal Server technologies remind me of the old screen scrapers that were used to place "green screen" applications on a Windows desktop. The device had changed, but the interface was essentially the same. Users were dissatisfied when they realized they had basically the same application with the old interface, but just running somewhere else.

With Magic Software's mobile offering, you will be able to develop through a single paradigm and still run natively on each device you want. This is a big difference and the main benefit for developers and end users. Without Mobile Magic Software’s mobile offering, you would need to program in several languages requiring different skillsets: NET Compact and Windows Forms for Windows Mobile, Java J2ME for BlackBerry devices, Java J2SE for Android, and Objective-C for the Apple iPhone. Magic Software’s mobile offering leverages metadata that allows you to use a single development paradigm and still run applications natively for all these devices, and you still have the ability to specify the use of the native look and feel of the device.

For more information, please click here to download the White Paper " Magic Software's Mobile Offering Technology Overview . "

Mobile Enterprise Application Platform: Any App...

2011-05-13T12:24:00.001-07:00

Enterprise mobility is in part a decision about “how to” develop and deploy mobile applications but it also involves serious questions about “what” applications to deploy. The fact that a good mobile enterprise application platform can make core enterprise software systems accessible remotely by a handheld device does not necessarily mean that all data and functionality should be exposed. Serious decisions need to be made about which data is accessible and which business functions are to be mobile-enabled. In this regard, it is important that you have all the tools in place to allow you to selectively integrate enterprise applications rather than simply providing wholesale access to your back end systems and processes.

With the announcement of Magic Software’s Mobile Offering yesterday, a new discussion of the importance of complex mobile business process and workflow was begun. See for example, the article in Dr. Dobbs Journal subtitled: “complex workflow support for mobile deployment of enterprise apps.”

Magic Software offers the mobile enterprise application platform you need to develop and deploy mobile apps and it provides the integration platform that enables connectivity and data interchange with your existing enterprise applications. Rather than engaging in extensive retooling of an existing application, you can use Magic Software’s iBOLT integration platform to automate the orchestration of data transformations, business transactions and application messaging with backend systems.

This automated approach to integration is the first step in reducing the effort required to mobilize any application. We then return our consideration to the mobile enterprise application platform itself. As a metadata engine, Magic Software’s uniPaaS application platform is a ready‐made business application engine containing pre‐written technical and administrative functions and services. It frees the developer to bypass the intensive technical code‐writing stage of application development and move quickly and efficiently to deployment.

The easiest way to grasp this concept is to see uniPaaS in action. The uniPaaS development environment is really a visual representation of application ‘assets’ and business rules stored in XML based ‘metadata’. This metadata business structure can be easily transferred from one deployment scenario to another (for example, Windows Mobile to BlackBerry) with minimal effort. And as discussed in our previous entry, it isn’t a matter of developing one core application and force fitting it onto various devices. Applications designed for iPhone and Android should have the unique look and feel of those devices. Instead, Magic Software’s Mobile offering allows you to customize your core business application for each device without having to refactor your core business logic or data structures.

For more information, please click here to download Magic Software’s Mobile Offering FAQ.

Event-Driven Programming

2011-05-09T15:19:00.000-07:00

Event-driven programming in uniPaaS allows for the flow of the program execution to be triggered by events and handled in a desired manner. Event-based software development in uniPaaS is based on the very powerful uniPaaS engine.

The uniPaaS engine distinguishes the uniPaaS application platform from other approaches to application development and deployment. With pre-built capability to perform complex data manipulations that are transparent to the developer and end-user, the uniPaaS engine is key to the productivity and performance provide by Magic Software’s approach to application development and deployment.

The engine includes a set of operations for the developer’s use in creating applications. It also serves up a structure of execution steps called logic units, which work with the operations to perform tasks for the end-user. The developer doesn’t have to tell the uniPaaS application platform how-to do its job. The uniPaaS engine already knows how to perform such actions as opening files, reading records, sorting, displaying data on the screen, and more.

Contrast this with traditional 3GL and 4GL languages where the developer has to provide detailed instructions through program code to tell a program how-to implement each and every step, regardless of how tedious, repetitive they are. Programmers developing in Java and other languages get very frustrated by the fact that they have to repeat programming done hundreds if not thousands of times before by others. Many throw up their hands on the whole process of programming and say “Been there, done that” while others almost seem to enjoy being slaves to their code. By contrast, uniPaaS saves the developer considerable amounts of time by supplying these built-in operations and execution steps.

Naturally, the uniPaaS engine includes extensive support for event driven programming. Events, triggers and handlers are built in concepts. uniPaaS lets you define the uniPaaS logic as a response to implicit and explicit events that may occur during the execution of a task.

For the uniPaaS developer, an event is simply a logical definition of an occurrence. An event can be handled by an event handler to perform a flow of operations that the developer chooses. An event can also be assigned as a trigger of another user-defined event. When the triggering event is raised, it triggers the user-defined event. But uniPaaS isn’t just aware of events, it also allows the developer to handle events very specifically. In uniPaaS, a handler is a set of operations designated to be performed when a specified event is raised.

There are a number of different event types managed by uniPaaS.

System events are triggered by defined keystroke combinations. uniPaaS developers can define keystroke combinations for system events in a dialog box.

A uniPaaS internal event is usually handled by uniPaaS itself. But you can define a new or additional handler for these internal events.

Additional user events can be defined in the Event repository by the developer.

Timer Events within uniPaaS are based on durations, so that for every time interval of a specified duration, the event is invoked.

Expression Events are vents that are triggered when an expression evaluates to True. If the expression evaluates to false, then the event is not triggered.

Error Events are invoked when database-related errors occur such as a duplicate index or record that has been changed by another user.

ActiveX events are still used in some programs that use COM objects and Active X. An ActiveX event is raised for COM objects. If the event has built-in variables, they are created in the handler. It should be noted that ActiveX events are not supported with rich client tasks.

.NET events are preferred in rich client mode, where uniPaaS includes full support for .NET variables and events. When an event has built-in variables, they are created as parameters in the handler with the relevant .NET type. You can also define an event handler without defining a variable. In such a case, you can write the object from which you want to select the event.

uniPaaS events can be project-related events, triggered during the execution of any of the project's programs or task-related events confined to a specific task in which they are defined or to the task and its subtasks.

An event can have more than one trigger and more than one handler. Each trigger can raise the event in a different scenario. One or more handlers can handle the event for each scenario. This allows for complex event driven programming while avoiding the complexity of line-by-line coding. The uniPaaS application platform is available commercially from Magic Software Enterprises.

MIUG 2011: MIUG Keynote Speaker Announced

2011-04-05T13:12:00.000-07:00

Magic Software’s Chief Technology Officer Eyal Pfeifel to Keynote Magic Software Users Conference and Lead Key Education Sessions in New Orleans May 3-5, 2011

Eyal PfeifelChief Technology Officer of Magic Software Enterprises, Ltd., will offer the Keynote address on “Magic Software's Technology Direction.”
In this session, he will present the Magic Software technology roadmap and vision. This year’s presentation should be of particular interest. In addition, Pfeifel will lead sessions on "Magic Software’s Mobile Offering" and "Working with .NET Components in Magic Applications".

Eyal Pfeifel is responsible for defining and implementing Magic Software's technology vision and overall product offering. Eyal comes to Magic Software with more than 20 years experience in planning and managing large-scale and innovative technology projects. Prior to joining Magic Software as CTO in 2009, Eyal was CTO for Ai Research and Technologies, a leading Artificial Intelligence research project. Eyal has served in executive positions in a diverse range of international hi-tech companies covering Internet, Consumer, Mobile, Enterprise and Reference software. Eyal has also previously worked at Magic Software's Japan branch as marketing general manager from 1998 to 2000 and as product manager at the company's headquarters from 1993 to 1998 and has a strong knowledge of application development and enterprise software.

Registration Deadline: April 22, 2010
To register, please call (949) 250-1718 and ask for Brian at ext. 232 or Megan at ext. 221. The conference registration fee is still only $599 and credit cards are accepted. Be sure to also reserve your room at the Renaissance New Orleans Pere Marquette Hotel. More information is available on the Jazzed on IT website at http://www.JazzedonIT.com

Comparing uniPaaS and Java: Can’t We All Just Get Along?

2011-03-17T17:04:00.000-07:00

Recently, we conducted an interesting challenge with uniPaaS Jet. We asked an independent developer already familiar with Java programming and having no previous uniPaaS experience to download uniPaaS Jet, learn it and create a simple program using uniPaaS Jet. (We had earlier asked them to create the same program using Java.) We asked them to take careful notes of the resources required and the effort involved. uniPaaS proved itself more efficient in every category. uniPaaS used half the memory and half the file storage. uniPaaS required barely 1% of the logical lines of code and 7% of the physical lines of code. The uniPaaS program executed for the first time in 1/10th the amount of time. The applied effort was 202 hours in Java and only 3.2 hours in uniPaaS. The project duration was 2.63 months in Java and part of a single day in uniPaaS.

Our purpose in reporting these findings is not to engage in Java bashing or point out Java weaknesses, in fact uniPaaS is very Java-friendly. We have some Java developers in our R&D department. And most important we believe uniPaaS can offer much to Java development teams to provide them with tools that can take advantage of their investment in Java while providing them the kind of advantages experienced by the independent developer mentioned above.

The Java Integration built into uniPaaS allows uniPaaS to interface with a Java class or Enterprise JavaBeans (EJB) by using pseudo-references that represent instances of Java classes or EJB files. Pseudo references are an identifier representing the values from a class instance in a BLOB variable. Programs must pass this identifier to access the methods and variables of a class instance. A Java class is a template definition of the methods and variables in a particular kind of object. An object can be a specific instance of a class and can contain real values instead of variables. For integration to Java classes by a uniPaaS application, you can access static methods and variables without the pseudo-reference.

Java instances, static methods and variables are invoked by uniPaaS’s Java and EJB functions. In Java, a class instance is a specific implementation of the Java class while a static class method is a class method that can be called without instantiating the class. Likewise, a static class variable is a class variable that can be accessed without instantiating the class.

An Enterprise Java Bean (EJB) is an architecture for defining Java program components that run on a client/server network. The uniPaaS EJB Component Generator is a wizard that generates a component containing uniPaaS programs that call a Java class or EJB functions. A Java Native Interface (JNI) lets non-Java programs interact with Java programs. The Java Component Generator is a wizard that lets uniPaaS automatically access Java classes or EJB files by creating a component that eliminates the need to specify JNI signatures. You can also use uniPaaS to generate Enterprise Java Beans (EJBs). Clients operating within a J2EE environment are able to view and activate uniPaaS programs as EJB methods. You create the EJBs using uniPaaS’s Component Builder utility.

uniPaaS can create an instance of a Java class that lets you activate a method, or query and update variables using a pseudo-reference. The pseudo-reference is a BLOB variable that represents the Java class instance. When a method is invoked, the BLOB variable returns values to the uniPaaS program as function return codes. Class static methods and variables can also be accessed without having an instance of the Java class by using the class name and the method or variable name.

The uniPaaS Java functions are used to simulate the calling methods in Java. Each context of the engine internally maps between the pseudo-reference and the actual reference.

For example, a uniPaaS program can call the JCreate function to create a pseudo-reference as Virtual Variable A. The actual reference to the instance is then internally associated with Virtual Variable A. Any uniPaaS program in the context will be able to access the methods and variables of the object by using JCall(A,...).
The Java functions can be called by a uniPaaS program to:

• Create a new instance of a Java class
• Call a method directly from the Java class or from an instance
• Report and return exceptions
• Query and update variable values

The EJB functions enable uniPaaS to explore and invoke Enterprise JavaBeans.

I think the important message here is that uniPaaS can help Java programmers make efficient use of Java classes and EJBs while benefitting from the efficiencies of uniPaaS’ smart application development platform. For additional information access the Magic Software DevNet or contact your local office.

Get Rich and Fit: RIA Inside the Firewall

2011-03-01T18:17:00.001-08:00

uniPaaS provides a comprehensive solution for Rich Client applications, sometimes referred to in the industry as Rich Internet Applications (RIA). While many assume that all the advantages of a RIA application stem from the benefits or need for remote application access, there are actually numerous reasons to consider RIA, or perhaps a better term, Rich Client applications, even when they will be running entirely within your own firewall on a Local Area Network (LAN).

uniPaaS is a platform for developing and deploying rich business applications serving n-tiered users based on Internet protocols. While the rich client approach uses standard internet protocols, this does not necessarily imply that application users are outside the firewall. In fact, uniPaaS RIA does not utilize Internet browsers such as Internet Explorer or Google Chrome but instead provides its own secure client to the user.

uniPaaS Rich Client Applications may be accessed securely, provide a fully interactive experience, and allow for automatic logic partitioning between clients and servers. User experiences are enhanced through an enhanced look and feel and accessibility of client-side resources in a browser free solution.

Developers benefit from a single unified IDE and development paradigm, performance-aware optimization during development and automated management of partitioning, communication and technical layers.

The resulting reduced Total Cost of Ownership (TCO) occurs because: there is no need for application-specific setups to access and run a Rich Client application; there is no need to manage the end-user's machine to accommodate application maintenance; and there is no need to install client-side software, such as Database-client and special printer drivers. Citrix servers are not needed to support RIA applications which can result in extensive long term cost savings.

Enhanced Interactivity and GUI. Rich client applications benefit from superior graphical and media capabilities as well as enhanced interactivity. This includes the ability to transfer and use files and resources from either the client or server. This enhanced document architecture enables superior enterprise content management and links between core enterprise applications and client side documents including knowledge worker productivity documents such as Word, Excel, PDF and other formats.

Enhanced Developer Productivity through Composite Applications Approach. With uniPaaS RIA, third-party .NET controls and assemblies can be used as the building blocks of applications. This reduces development time dramatically and provides access to enhanced, standards-based GUI experiences for users. Ability to incorporate standard controls enhances the openness of the , improves the user experience and reduces development time.

Fit Client. The Rich Client deployment mode allows for Server-Side Functions; Client-Side functions and Functions that can be executed on either the client or the server. Furthermore, RIA applications make better use of available computing resources. The Rich Client is neither a fat client nor a thin client. Through partitioning, you have what may be called a fit client, meaning that application functions may be executed on either the client side or server side. uniPaaS supports expressions on either the client-side or server-side. Developer functions are also supported on either client side or server side. This reduces the processing and memory utilization load on both the server and the client, and in the long-term makes for a lower cost , more energy efficient computing environment.

Parallel Execution. Several Rich Client programs can run simultaneously by using the Parallel Execution task property. For example, one program for employee management, and another for finance, all from a single entry point, without having to repeat authentication for each parallel program. Rich Client also supports MDI (Multiple Document Interface).

Mobile Application Support. Developing mobile applications with uniPaaS is based on uniPaaS RIA. The main difference between regular RIA and Mobile RIA is the consideration of the mobile devices’ view area and the expected user experience, such as touch screen and styles, and the deployment methodology. The RC Deployment wizard of the uniPaaS Studio simplifies Mobile deployment.

Hot Fixes and Updates. With Rich Client, the deployed uniPaaS application can be updated without the need to stop the application and log out all users. Known as “hot fixes” in the industry, this capability allows you to deploy your updates and fixes in a live environment.

Security. The Rich Client environment also has the advantage of reducing security administration and overhead. In a client server environment, there are risks associated with providing client access to servers. RIA applications interact at arm’s length and use secure encrypted communications and transport throughout.