Encore! Encore! Is it Time for a Little Sequel in Your Magic Applications?

 Migrating a flat file or Btrieve type application to the Magic uniPaaS Application Platform using a SQL database can deliver an organization numerous benefits.  Structured Query Language (SQL) databases provide an enterprise class data platform for use in business applications. Most developers would agree that SQL databases are preferred for enterprise-class business applications developed on the Magic uniPaaS Application Platform. Why?

SQL provides: a more robust data functionality to support business requirements such as OLTP and data warehousing; higher levels of security for mission-critical applications; the ability to apply business rules from within the database; and support for increased levels of transaction activity.

Because SQL is a popular concept used in databases such as MS-SQL, DB2 and Oracle databases, it is widely supported by a variety of data management, business applications, reporting and business intelligence tools. Not only are connections to other systems simplified, applications built on SQL are more future-proof than other applications. Standardization on SQL makes it easier for an organization to manage its data regardless of its use context.

SQL databases provided an advanced environment for data security that can be achieved through high level tools.In addition, identity management and control over information access is simplified through SQL across multiple applications.

In general, SQL is better suited to very large database sizes and maintains a higher degree of transactional integrity and operational reliability. In other words, it is less likely to crash. Data integrity can be maintained on the database level and metadata is more easily tracked for purposes such as audit logs.

While there are costs associated with most SQL databases, there are also express or light versions of SQL databases available for more cost-sensitive applications.

Most Magic uniPaaS Application Platform installations rely upon SQL as their primary database, in part because SQL can deliver database level functionality not inherent to other approaches:

·         Sequence and identity mechanisms are included in SQL databases for better multi-user application functionality.

·         SQL statements provide functionality for better application maintenance such as version updates, updated field definitions, table structure conversions, and added fields and indexes.

·         The Where clause is a powerful feature of SQL databases that allows for advanced filtering.

Because SQL can incorporate logical transactions at the database level, use of stored procedures, and an object-oriented methodology, it is often viewed as a superior choice for all sizes and types of applications.

Mobile-to-Mobile Integration in the Cloud

The Super Bowl is over so it’s time to kickoff a super idea: “mobile-to-mobile integration in the cloud.” We’re all thinking about it but we’re just not saying it: the current end game is to have millions of mobile apps on billions of mobile smartphones all integrated via the cloud. The IT department will consist of one person, the CIO, who outsources all IT functions to a team in India/ China/Brazil /Ukraine/Tanzania (you choose), who implements the CIOs ideas based on a series of virtual use case interviews on a bunch of transparent virtual machines up in the cloud. Every pertinent interaction and piece of data created and consumed on one user’s smartphone is instantly and securely available as needed by all other players in the business process. Far fetched? Do you disagree that this is where we are heading?

When you think about it, Magic Software’s applicationplatform, mobile offering and integration platform combined with its planned cloud offering have all the components needed to make this happen, except of course for the cool as a cucumber CIO that it would take to have the guts to implement a strategy like this. The coming metadata world is so highly virtualized that it’s possible to use the world’s best infrastructure without owning anything other than smartphones.

That being the case, the future of software development is in mobile app development and cloud applications. As we move into the present capabilities more fully we will see a future where Mobile Enterprise Application Platforms (MEAP), Infrastructure-as-a-Service (IaaS), Platform-as-a-Service (PaaS) and Software-as-a-Service (SaaS) are so ubiquitous that mobile-to-mobile integration in the cloud is not only expected, it will be demanded by business users.

Holding all of this back is simple adhesion to existing systems. But here again, if one can find a nearly transparent way to integrate existing systems with mobile-to-mobile integration in the cloud then organizational resistance is futile. Business leaders will drive the process of mobile-to-mobile cloud integration forward as the cost of dynamically creating integrated applications and apps becomes less than the cost to maintain the current state of data center possessing IT departments which are typically weighed down by excessive Java overheads and heavy, overlapping middleware solutions. 

The pressure from smaller fiercely competitive organizations using agile concepts and metadata driven solutions will force Big IT to break ties with old ideas and embrace the mobile-to-mobile cloud integration future. In the meantime, billions of the rest of us will happily type on big keyboards safe inside the protection of our client server applications behind the firewall as colleagues foist loads of data over the firewall via Web applications. Either way, the technology sounds like Magic to me.

Dealing With Effectiveness Roadblocks in Software Change Management

In our previous review of major concerns in the practice of software change management, we focused on communication issues and analysis and identification problems. Other problems areas identified in both academic research and the literature of practitioners include effectiveness roadblocks, decision-making challenges, traceability issues and problems with tools. We have already established that third-generation languages (3GL) such as Java, RPG, COBOL and the various C-languages (C, C#, C++) all have characteristics that contribute negatively to the ability of an organization to achieve best results in the practice of software change management.

At this time, I would like to engage in a high-level overview of effectiveness roadblocksin software development and software change management. Software development managers should consider how inadequate testing, poor tool support, hardware and infrastructure inconsistencies and the inherent constraints of direct source code maintenance contribute to developer sluggishness and overall software development ineffectiveness.

Concurrent or parallel development rears its head again as a source of development challenges. It should be cear that no one is suggesting that parallel or concurrent development approaches must be avoided in order for software to be effective. Although, many developers utilizing more advanced tools will suggest that a one person development teamcan accomplish more than teams working in parallel.

Obviously, concurrent development necessitates greater and more frequent communication between developers, business analysts, stakeholders and users. Communication is, of course, a vital and necessary aspect of any development project as previously discussed. Nevertheless, communication is a source of errors, or more to the point mistakes in communication lead to errors. But effectiveness issues also contribute to the problematic nature of parallel efforts. 

Application platforms help deal with effectiveness issues in software change management and software development. A metadata-driven application platform provides software “applistructure” that helps avoid many concurrent development issues. By virtualizing the hardware environment, these platforms leverage metadata to reduce the programming effort. 

Higher level approaches that avoid line-by-line coding are not prone to experience the problems introduced by code optimization. And even if an optimizer is used, readability is unaffected. The pre-compiled and tested capabilities of a platform are essentially pre-optimized.

Expectations for high availability rather than inducing high costs and practical limitations that prevent responsive software change management are better met with an application platform approach which introduces a higher potential for stability, scalability and robustness in finished applications. Application platforms are “maintenance friendly” because software changes introduce less risk. Ironically, change avoidance can ultimately put previously stable software at risk as changes in application environments introduce new unknowns as changes in operating systems, database and other systems inevitably creep in. Those concerned with software change management must pay careful attention to the future-proof nature of application platforms versus 3GLs. A metadata-driven application platform with a repository-based approach will go a long way towards providing the assurance that whatever underlying changes are introduced, the platform vendor will be able to provide a way forward that protects your investment in your applications and allows you to maintain your applications with a minimum of effort..

In parallel efforts, integration architecture is necessarily incomplete in the early phases of a project. Testing errors occur because it is impossible or difficult to in a 3GL to anticipate testing oversights. A more advanced application development platform may be a solution in particular because of the repository based aspects of some application platforms. Also, underlying architecture is part of the platform and not the development effort and so de rigueur testing has already been accomplished by the platform provider.

Other aspects of the project architecture, up to and including hardware  requirements aremore likely  incomplete at the beginning of a 3GL project, which leads to requirement changes on software created by subsequent architectural changes not anticipated in the beginning stages of the lower level efforts.

Source code optimization also relates to effectiveness problems impacting software change management and software development overall. For one thing, optimized source code is difficult to understand. Changes are more difficult because it takes extra time to figure out what is going on with the optimized code. It’s also difficult to pinpoint issues in testing to separate problems in the optimized code. 

Application platforms help deal with effectiveness issues in software change management and software development. A metadata-driven application platform provides software “applistructure” that helps avoid many concurrent development issues. By virtualizing the hardware environment, these platforms leverage metadata to reduce the programming effort.

Higher level approaches that avoid line-by-line coding are not prone to experience the problems introduced by code optimization. And even if an optimizer is used, readability is unaffected. The pre-compiled and tested capabilities of a platform are essentially pre-optimized..

Expectations for high availability rather than inducing high costs and practical limitations that prevent responsive software change management are better met with an application platform approach which introduces a higher potential for stability, scalability and robustness in finished applications. Application platforms are “maintenance friendly” because software changes introduce less risk. Ironically, change avoidance can ultimately put previously stable software at risk as changes in application environments introduce new unknowns as changes in operating systems, database and other systems inevitably creep in. Those concerned with software change management must pay careful attention to the future-proof nature of application platforms versus 3GLs. A metadata-driven application platform with a repository-based approach will go a long way towards providing the assurance that whatever underlying changes are introduced, the platform vendor will be able to provide a way forward that protects your investment in your applications and allows you to maintain your applications with a minimum of effort..

The Problem of Communication in Software Change Management

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

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

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

Magic Software’s uniPaaS Application Platformincludes 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.