Forem: Jasmine Morgan

The Revolution of AI in Software Testing: Top 7 Takeaways

Jasmine Morgan — Mon, 30 Apr 2018 10:08:53 +0000

Software testing makes the difference between a top-tier digital product and an average one. Not only does automatic testing massively replace manual testing, but a new advancement is about to enter the scene. Artificial intelligence development has already proven to be a winning strategy in a wide range of sectors, including financial trading, retail, and even cancer detection. Now it is time to bring its power into this area, and help testers make sense of petabytes of data in the shortest amount of time.

Is manual testing dead?

Manual testing will soon no longer be an option due to its rising costs and because it increases the time-span necessary to create a viable product. Furthermore, though manual testing only a limited amount of cases or scenarios can be handled. Also, it was not designed for the complexity currently posed by the growing number of IoT. In the words of Jason Arbon, manual testing is comparable to rolling down a car window by hand, a gesture that future generations will not understand and will be puzzled by its necessity.
On the contrary, testing based on AI is fast, traceable, and reliable. It offers the opportunity for the bots to learn on their own and has no limit to the amount of data to be tested. The best news is that in this case, there are early red flags and quick action can be taken.

Improvements in software testing through AI

Using AI for software testing comes with improvements in speed, quality, maintenance, and compatibility. The new technology offers the opportunity to track results, create databases with past outcomes and ultimately acts as a way to let go of redundancy. Here are the top reasons to consider AI for software testing, including websites, apps, and IoT devices.

Automation & cost reduction

Testing bots are designed to perform on their own, with no outside intervention unless it means a new set of training data. This means excellent cost-efficiency due to removing the need for long man-hours performed by manual testers. We will no longer need to select, manage and drive SUTs, as AI will do this for us.
Testing is a repetitive action; therefore, speed and reliability are top priorities. AI learned to recognize cancer from pictures as good as physicians, if not better. Using the same logic it can learn to identify the desirable patterns, allowing the testers to develop better cases in the meantime.

Non-deterministic

There is an essential difference between automation and AI. A lot of manual testing can be automated by hard-coding, yet AI offers a whole different range of opportunities since it can learn from past experiences and make decisions. Shortly put, it is non-deterministic, since the neuronal layers can create new answers to new questions by combining pre-existent inputs and expected outputs. Currently, the most significant challenge of working with such systems is that there is a range of possible outcomes and the algorithm needs to learn the best choice. A way to do this is to isolate data and look at system results.

Early feedback and fast testing

By automating the processes, development teams, aided by testers can identify and isolate bugs quickly. Also, since the whole process is performed by bots, it means that it is possible to study more cases at once and pinpoint problems before moving into a new phase. This helps eliminate the errors rapidly and create logs that record changes and constitute a learning base.
Bots can create test cases and replicate themselves to act as thousands or millions of different end-users, powering through the software product in as little as one hour. They gather details about bugs, error dialogues, crashes, incompatibilities and put all that together in a report.

Little maintenance

The advantage of using bots is that these adapt on the spot to changes and identify new paths and patterns. The algorithms can instantly learn about new requirements and quickly identify new failure patterns or defects. All you need to do is provide a few new sets of training data, and they are good to go.
The prediction is that in the future, software testing engineers will build AI systems that will test other AI systems, thus crossing the line between QA and data science.

Increased quality

Manual testing, through its repetitive and dull nature, was prone to errors caused by boredom and attention slips. When the same actions are performed on multi-core machines by bots, the chance of an honest mistake is null, dramatically increasing the end product. Furthermore, bots will become highly specialized, testing only a single feature, like a button or a search box.

Compatibility

Most software applications for current devices should be able to perform flawlessly on a very different range of devices. AI can act as an emulator of the end-user equipped with various terminals, all without leaving a single platform which gathers all the results in a matter of moments. Once some tests were performed, the results can be centralized and analyzed to identify problems.

Traceability

Manual testers were forced to keep detailed logs of their work, usually using spreadsheets or dedicated platforms. By using AI, all the tests, results, changes, error codes and other data are automatically stored after each batch of tests, offering a way to validate what was already tested and even creating a training set for new test instances.

Will testers be out of work?

A recurring theme when talking about AI and automation is the fear of specialists becoming redundant and losing their jobs to machines. As the previous industrial revolutions proved, this is true up to a degree. People will be replaced by computers in performing tedious and repetitive work that is error-prone and does not require human capabilities such as critical thinking and problem-solving. In fact, software testers will be free from mindless tasks and more able to focus on limit cases and less frequent situations. AI for testing shouldn’t be intimidating since it sets the record straight: it gives machines the tedious work and people the time to think and be creative.

Almost Native, But Does React Native Performance Measure Up?

Jasmine Morgan — Mon, 12 Mar 2018 18:03:07 +0000

It has become almost universally recognized that cross-platform mobile app development can save time and money compared with building discrete native apps for iOS and Android.

But if your company is new to the idea of building cross-platform apps, it can be tricky to choose between the many available mobile application development services and the tools used by the providers of these services.

Perhaps you have already started to evaluate your options, and you may have heard that despite being a relative newcomer to the cross-platform development arena, React Native (RN) is one such tool that's fast growing in popularity.

In fact, it's currently considered one of the most promising solutions for creating native-style apps, but nevertheless it's only natural to wonder if React Native performance can really match that of pure Swift or Java.

Launch and Response Time

First impressions are everything, so the speed at which your mobile apps launch and begin communicating with the backend is critical to success. Indeed, according to Apteligent, 50% of consumer-grade app users find slow load times to be a major source of frustration, hence launch and response speed must take precedence during user-experience optimization. App performance, including the loading speed, is also a sore point among enterprise users, as the statistics below (compiled by CIO Insight) illustrate.

Now as with all the React Native performance criteria covered in this article, it's impossible to offer a universal performance comparison between true native apps and those created with RN or any other cross-platform development alternative. In reality, so many different factors come into play that it's unrealistic to seek an absolute benchmark. It is possible to offer a general comparison though, by analyzing the characteristics of native apps and cross-platform apps built on React Native.

React Native: Near Native Launch and Response Time

React Native is a JavaScript framework. If you ask your developers about JavaScript, they will undoubtedly tell you it's notorious for slow execution speed, especially on Android devices.

The good news is that React Native mitigates some of the JavaScript performance weaknesses, perhaps most importantly by allowing developers to drop in native code wherever it makes sense to do so. The important point to note here is that you don't have to try and create apps entirely with a single code-base.

This non-prescriptive approach to app development makes it entirely possible to create apps that load nearly as fast as true native apps (provided your developers aren't tasked with building apps quickly and cheaply at the expense of all else).

Remember though, that like all cross-platform frameworks, there is a certain amount of extra software overhead involved in creating apps with React Native, which inevitably makes them slightly heavier than native apps and potentially a little slower to load.

Mobile App Reaction Time

Of course, launch speed is only the starting point for mobile app users to judge performance. It's just as critical for an app to react and respond quickly to the user's input.

React Native is a real winner in this respect, not least because instead of being CPU-intensive like most native software, RN apps make greater use of the mobile device GPU. Furthermore, they can be made to use the GPU just as efficiently as true native apps.

For instance, developer John A. Calderaio built and tested two identical apps for Apple devices. One was developed with native code (Swift), and the other with React Native. While the true native app performed with a greater CPU efficiency than the React Native version, the difference was just under 18%, which is not especially significant.

In his GPU test, John's React Native app achieved almost the same frame-per-second performance as the native variant. The results of this test can be seen in the chart below.

React Native vs. Java (Android) Apps

You might have noted that most of the direct comparisons mentioned so far are between RN and native Swift and indeed, this is the scenario in which React Native performs best. A comparison with Java-based apps paints a slightly different picture.

It has to be said that when asked about RN versus Java, some developers express frustration with the cross-platform framework. Memory issues in particular seem to prevail when using React Native to develop apps for Android.

However, this doesn’t mean that React Native is unsuitable for building Android apps. Solutions can be found for many of the memory problems. Such solutions might include any or all of the following examples:

Ensuring that images requested from your server are no larger than necessary for views showing many images simultaneously.
Making sure static images are in the JPG format (not in PNG).
Setting LargeHeap to "true" in AndroidManifest.xml.

Above all, it is important to understand that developers using RN to build Android apps need a little more creativity to optimize performance than might be necessary for the iOS platform.

Remember to Consider Development Performance

When everything is taken into account, there's little to suggest that React Native lacks the performance to match native apps. Small gaps, if any, are more than made up for by the benefits offered to development companies—or to your own enterprise if you intend to deliver mobile apps using internal resources.

These benefits—such as the ability to write much of the code using a single language and to integrate native code only as necessary—make it possible to reduce the time required to create apps. They also allow for smaller engineering teams and reduce development costs.

In short, React Native can improve development productivity and performance, without a significant trade-off in terms of app quality. That alone makes a compelling case to settle upon RN as your cross-platform framework of choice.

Is React Native the Solution for you?

If you do decide to work with React Native, or if you're already doing so, what were the key factors in your decision?

Is there anything that would make you pick another alternative such as Xamarin or Adobe's Cordova? Or do you still believe that the extra effort and cost of building disparate native apps is acceptable to ensure the best possible user experience?

Please feel free to post a comment or two with your views and especially your experience if you're already using React Native for your company's apps.

Looking at Challenges of Big Data Testing with Hadoop

Jasmine Morgan — Thu, 21 Dec 2017 18:29:17 +0000

Have you ever imagined how a baggage sorting system works in a busy airport? Have you ever thought how your GPS knows which part of the road is crowded? Do you ever wonder how social media companies make sure every post is processed fact and displayed to those most likely to interact with it? These are just a few examples of why Big Data testing is important. You could even go a bit further and think about how the world would look like if the information that is created every second would not be adequately tested.

The Need to Test Big Data

The term Big Data is a binding concept which denotes any set of recordings that is too large to be stored and analyzed on a single machine. It has become a way to make better decisions, personalize content, automate responses and unveil hidden patterns that could offer a competitive advantage.

Its difference from regular large databases is that the majority of such data doesn’t follow the structure of conditional databases and can’t be set in a table.

It comes mostly as unstructured (video, audio, maps) or semi-structured (CSV files, XML, JSON) data. This makes traditional testing methods inappropriate and inaccurate and calls for the need to develop specific ways to deal with accuracy and quality assurance.

How Is Big Data Testing Different?

As listed by software testing company A1QA, software testing includes various aspects related to data and its use:

● Functional testing
● Performance testing
● Security testing
● Compatibility testing
● Usability testing

These aspects are more about the use of software. Meanwhile, the most significant issue of Big Data testing is related to its quality, and the focus will be on validating it by checking completeness, ensuring that it is ready to be transformed and that it has no missing records. All these are necessary before it is analyzed.

The testing process consists of three distinct stages, including the validation (pre-Hadoop), Map Reduce and logic checking, and validation of the output.

The problem with Big Data validation is that the tools used until now, namely the minus query and sampling methods, are useless.

The minus query method applied to SQL databases compares each row in the original set with every row in the destination, which means significant resource consumption. Multiply this process by two, since it must be performed both ways (source-target/target-source) and you are already falling behind. Not to mention that if the data is unstructured, like CCTV footage, the process is inapplicable.

The sampling method (“stare and compare”) is also a waste of time and can’t be used for datasets that have millions of lines and which are updated every second in some cases. For Big Data, automation is necessary, and manual sampling for accuracy should be eliminated.

Challenges & Solutions

Since Big Data is analyzed through distributed and parallel systems, the problems that arise are linked to processing the entire volume of data, doing so in a reasonable time, safely, and ensuring the transmission of all the records. The challenges here arise from the 3Vs defining the Big Data: volume, velocity, and variety.

The Problem with Scale

The first V, volume, requires the system to be able to handle large incoming data streams. To be ready to face these problems, the best approach is to use a distributed file system, like HDFS powered by Hadoop. The great advantage of this framework is that it requires little changes to go from a few to hundreds of processing nodes. Therefore, it is enough to have the logic in place for testing.

The system includes redundancy since each piece of data is replicated along more nodes to prevent information loss in case some of the network nodes fail. Generally, it takes a failure of more than 50% of the network to lose data. Possible additional problems here may come from synchronization between nodes.

The Problem with Speed

A system is only valuable if it performs fast. Using parallelism can ensure the result is given promptly, spreading the task over multiple CPUs. This required dividing the information in such a way that computations can be performed on segments without affecting the result. If two different nodes need the same information, it can be replicated or serialized.

The tool used to solve this is the NoSQL approach, which is perfect for Big Data since it is perfectly adapted to unstructured records. To speed up the search process in such a structure, indexing is necessary, which can be done by using Cassandra.

The Problem with Security

The rising problem of cyberterrorism makes security testing an integrated component of any testing suite. Any vulnerability in the infrastructure gathering the Big Data, such as Wi-Fi or sensors, could be exploited to get access to the data lake and compromise the organization’s records. Hadoop instances are known to be quite insecure. Therefore, a data penetration test is required.

Verifying Accuracy & Compatibility

Since in a parallel computing system some nodes can fail, it should be an integral part of testing to check that data is replicated correctly across the nodes, processed appropriately in each node, and that the result is transmitted in due time to the master node of the Hadoop system.

Due to the varied nature of the data, the testing should also run for compatibility between inputs, the system’s capacity to analyze those types of data, and outputs.

Conclusions

Big Data testing should address each of the problems raised by the 3Vs, to create the fourth - value. There are significant differences between standard software and data testing related to infrastructure, tools, processes and existing know-how. To cope with the challenges posed by Big Data, testers need to use parallel computing, automate testing and keep in mind issues related to data privacy and security. A clear testing strategy for database testing and infrastructure followed by performance and functional testing types also helps.

Will Hadoop-based Recommendation Engines Make Search Obsolete?

Jasmine Morgan — Tue, 05 Dec 2017 18:30:11 +0000

Do you feel overwhelmed by information? Would you love to get precisely what you need without answering numerous questions or going through a difficult filtering process? Enter the recommendation engine, a tool designed to give you more of what you love, based on your own past preferences or those of people like you. The raw matter that is converted into recommendations is data, and lots of it.
The challenge is processing customer-related data that is so large it doesn’t fit on a single machine. Hence the term Big Data, which is characterized by the 3 Vs: volume, velocity, and variety. Google proposed the MapReduce model, and the Hadoop tool emerged as a way of breaking down data into clusters, analyzing them separately and putting together the result.

The MapReduce Architecture and Hadoop

The large datasets previously mentioned are more than traditional processing tools can handle. To understand the MapReduce approach, you can imagine an organization has just won a data processing project. The project manager distributes similar tasks to employees in the mapping phase, then each worker does their part, basically the same job distributed over many nodes. When they are done, the project manager (master node) centralizes the results, in what it is called the reduce phase.
In fact, instead of moving data towards a processing unity, the new approach is to run the analysis where the data is stored and only sent through the network the final results. This saves time and bandwidth. Hadoop is a tool that facilitates these actions in an accessible, robust, scalable and straightforward manner.

Collaborative filtering, Content-based and Hybrid

Recommendation engines can be built either by taking all past choices of a single user and trying to guess the trend and future preferences or by aggregating the likes of similar users and computing the most likely next move.
Content-based filtering takes as input the tags of the data. For example, in the case of a movie, it could use the genre, name of the actors, director, keywords for the storyline, place it was filmed and so on. It also requires building a user profile with past movies watched, favorite stars, preferred genre and some demographics. The result is given by a technique called cosine similarity which compares the two sets of data.
For collaborative filtering, user behavior is more important, and the data gathered reflects preferences, ratings, shares, comments, signaling interest in a specific piece. Again, the profile of the user is created from third-party data gathered from browser history or through their social media profile if they used a social login. The significant advantage of collaborative filtering is that it can offer very accurate recommendations to new users since it doesn’t require any direct input. This is useful for sites that want to personalize the experience for first-time users.
Of course, there is also the opportunity of mixing the two systems to create a laser-precision recommendation system, which uses both collaborative filtering to give more diversity and content-based to select only those items that would be perfect for the user, saving them time.

Putting the pieces together

Both techniques to build recommendation engines are suitable for Hadoop MapReduce. For example, in a collaborative filtering scenario, the data loaded in the HDFS (Hadoop Distributed File System) could be the ratings and reviews of books on Amazon. The system will perform distributed text parsing, extracting words, counting them and classifying into sentiment analysis clusters.
Based on this information, in a hybrid system, if a buyer is logged into their account, they will receive items classified according to a preference order. This order is determined by cluster analysis. Each user is distributed in a cluster by measuring the distance between their preferences and the average preferences of that group, denoted as the cluster center.
For anonymous users, the system can just use a handful of information and create a general set of recommendations. These are based on the location or some information like the device used and previously browsed pages.

Data issues

In the implementation phase, data science consultants from InData Labs warn about the importance of data quality and consistency. Since the input is gathered from unstructured sources and it is generated by users following no constraints, a cleaning and structuring process is necessary.
A potential challenge is given by multilingual sites, where there is a decision to be made if the results will be presented in an aggregated way, using translation or individually, per region. Of course, this is dictated by the application’s logic and business goals.

How good is a recommendation engine?

Of course, regardless of the chosen architecture, one can ask just how good an individual recommendation engine is. Just building it is not enough, it needs to be validated for accuracy and precision.
Accuracy can be defined as the ratio between the right guesses of the system (true positives and true negatives) divided by all possible results. Meanwhile, precision is the ratio between true positives and the sum of true positives and false positives, mainly showing the percentage of correct guesses.
Positives and negatives are determined by sentiment analysis by classifying the words used by clients in reviews in the appropriate clusters. Special attention needs to be paid to the ironic tone which can be misclassified as positive.
There is one more metric that can be used to measure, the recall. This is defined as the number of relevant reviews retrieved by a search divided by the total number of existing reviews documents.

The search of the next decade

In a world where recommendation engines know the customer so well, we can expect to reach the pinnacle of search, defined as “no search.” Based on the result computed by the machine, the user is supposed to be so happy with the returned result that they accept it without further changes. This is a significant difference when compared to the complicated query syntax of SQL, and even the specialized Google queries available today. We could expect a “mind reader” search option based on third-party data such as browser cookies and social media preferences, all neatly filtered through Hadoop.

3 Challenges of Building a Big Data Backend for Your Enterprise Mobile App

Jasmine Morgan — Tue, 24 Oct 2017 19:54:42 +0000

Most apps bring value by giving access to the Internet and providing the user with real-time feedback on their questions and actions. Few, if any, enterprise apps are standalone and don’t require Internet connection. Those are just mere displays for static information. This is the reason why it is worth thinking about the backend and APIs to enrich enterprise app functionality.

Understanding the Dark World of the Backend

For an app developer, the backend can be intimidating since it requires a different set of skills to deal with servers and databases which are governed by cryptography and security rules. When working with Big Data, there are even more requirements, like those related to handling the Hadoop framework.

Delegate to Server

Since mobile devices have limited resources compared to servers, it’s best to move all the computational work to a powerful machine and only communicate the result to the user. For the developer, this helps to build the app for different platforms and just integrate it at the end.

Plan for Offline Back-up

Users can have low signal problems or no Internet connection at all while using the app. A well-designed piece of software can create local back-ups of data and resync with the server once a link is available. In case the app works with Big Data, it is essential that the volume of data stored offline is not larger than the device’s capacity.

Address Synchronization Issues

In Big Data projects, due to the “velocity” dimension, synchronization drives quality and helps to solve data conflicts. The rule of thumb is to give priority to the latest version of a dataset based on a timestamp and ensure time zone differences are addressed.

The in-house experts in enterprise mobile app development from Itranstion stated that sync for mobile apps should take into consideration the inherent limitations of devices, such as battery life, cost of data transfer and signal power. Also, the operation should only be performed when certain thresholds are met to avoid power drainage during sync or losing signal.

Selecting the Right Query Tool: SQL vs. NoSQL

In the last 40 years, SQL became the standard when it comes to database query since it allows numerous interrogations of the same information set, adapted to the user’s needs. It has a long history, and it is already integrated into multiple tools. This is a relational tool, and the main downside is that it scales vertically by adding more resources to the server.

On the other hand, NoSQL has become popular due to Big Data and Internet giants like Facebook and LinkedIn. NoSQL is excellent for flexibility, as it has no fixed schema behind it, but can just evolve and get new properties as needed. It was designed for semi-structured data; thus, it can be easily scaled horizontally by distributing data across servers.

SQL is declarative, the only thing the user need to do is to ask for the right information, and it will get it in the form already existing in the system. By contrast, NoSQL, as a procedural query, demands from the user to specify the final type of the answer. Since in the procedural approach the programmer has to redesign the system each time, it is more costly and less user-friendly.

To overcome this problem, there are SQL implementations that can query HDFS systems, apart from Hive, which was the original query tool of Hadoop.

Fixing Security Issues

It’s true an app is as secure as its code, but it’s also as secure as its backend, sometimes entirely controlled by the vendor. A recent study has shown that over 43TB of enterprise data coming from over 1,000 apps were exposed and prone to personal data theft. This problem was nicknamed “The Hospital Gown” vulnerability. The problem is made worse by the fact that companies can’t detect a breach until it’s too late, as signaled by ransomware and phishing tentative.

The report highlighted that the primary problem was the lack of security items between the vendor of the data storage and the Internet, although there were proper firewalls set between the app and the data storage.

Solutions to Security Issues

The first step is to create an inventory of all the apps used in your company and the permissions each has. A simple spreadsheet will do. Update to the latest versions and remove all apps that are no longer necessary.

Secondly, make sure you agree with your vendors on the way your data is stored and protected. It’s mandatory that the backend is secured, and the information encrypted using the latest standards. Lastly, make sure that the data from the server is recent and has not been compromised.

Is Backend as a Service (BaaS) a Viable Solution?

If the developer doesn’t want to deal with the problems posed by the backend, BaaS means that you outsource the implementation and connect to the environment provided by the vendor through APIs and SDKs. In this case, you delegate entirely the responsibility for architecture, speed and security to your vendor to give you time to focus on your core abilities.

The good news is that most of these services are built on the freemium model, and you can scale as you grow your own client base. On the downside, BaaS can limit your options and offer too low customization options. The recent case of Parse discontinuing its services is also a noteworthy alarm sign. Switching providers can be costly, involve redesign, possible downtime and client loss.

Final Thoughts

Building a fast, secure and reliable enterprise mobile app requires more than design and UI/UX skills. The powerhouse able to process Big Data is the backend, which should be built for scalability, following best practices of security and data protection. The architecture must address the query type, synchronization issues and be adapted to accommodate different types of data, including semi-structured and unstructured ones.

Due to the sensitive nature of enterprise information, data security should be on top of the developer’s priority list. Blind trust in the vendors’ systems can have unwanted consequences.

What You Need to Know about Ionic 2?

Jasmine Morgan — Tue, 10 Oct 2017 18:53:35 +0000

To some extent, being a developer means taking your time to refresh your knowledge and to learn new things related to tools, concepts, and frameworks. In the world of mobile apps development, one of the most successful open-source projects today is Ionic, which is already behind over 1.2 million apps. The reason for this success is that it allows to create hybrid apps with native capabilities.
We are still talking about Ionic 1, but the popularity of the tool convinced its developers to expand it and introduce the world to Ionic 2, which is not only new, better and improved, but is a revolution as it has already been adopted by 73% of developers. But what makes this new version so popular?

Simplicity & Organization

The Ionic 2 template syntax has the beauty of Japanese Zen gardens. Compared to Ionic 1, it is cleaner, more straightforward and even enhances the functionality. You can change triggering events by merely changing a handler.
This is also an excellent tool for beginners, since it is much more intuitive and with less fluff, but it also forces the developer to stay organized. By attaching a folder to each component, it is entirely modular, including a class file, a template file, and a style file.
The ES6 syntax is automatically transpiled into ES5 through TypeScript and allows you to benefit from a simple, understandable code. Another plus is using productivity tools like autocomplete, module import and tooltip definitions.
The CLI v2 is also an essential improvement due to its ability to generate pages, pipelines and other components in the command line.

Performance

Since Ionic 2 is built on Angular 2.0 or higher, it includes the changes made to the Document Object Model (DOM). The reaction time is significantly improved compared to Angular 1.0 and is now comparable with React. Speed is also essential when it comes to app loading time, scrolling through long lists and playing games.
The new lightning speed is given by Ahead of Time Compilation (AoT) that pre-compiles templates and saves up to a few seconds when compared to in-browser compilation. The app package is smaller as there is no compiler in the bundle, which makes apps download faster.

New Components

The building blocks in Ionic are called components and are like a developer’s LEGO. The real news here is the support for Material Design encouraging the use of UI components.
While the first version offered enough components to create great apps, this new one is going an extra mile to bring menus, buttons and other tools, including navigation and modals. A recent article on Iflexion highlights two of the most useful new components: the DateTime, which can be helpful for calendars and scheduling, and the Floating, which gets the app to mimic the behavior of the Facebook Messenger.

Design

The Ionic framework is known for its ability to offer components that are created by the standards of professional designers. The best part is the Platform Continuity concept, which ensures that each item in an app will look as expected when deployed on a platform. You can see different views in the Ionic Serve Lab, side by side. Simply put, it means ‘write once, run anywhere’. Meeting user expectations is a key principle of UI/UX, and Ionic strives to perform at its best.
One of the most striking design features of the new framework is native scrolling. This dramatically enhances user experience by presenting them with a smooth scroll on each of the three platforms (iOS, Android, Windows Phone).

Building

In this matter, Ionic 2 takes an entirely different route compared to Ionic 1. The app folder contains the code which is transpiled to one JavaScript file that will be served to the browser. The advantage is speed, but on the downside, debugging the bundled code is more difficult. Also, the pre-built version is not minified, which can have a small impact on the loading time.
An exciting change was replacing the URL navigation with push/pop commands. This helps the app behave more natively.

Handling errors

One outstanding feature of the Ionic 2 SDK is the error reporting tool. This operates instantly and catches problems on the fly, right in the developer mode. No longer should you risk propagating errors in the final versions of the app. This also saves some testing time while speeding development, since there is no need to go back and forth to the terminal. This feature comes as a counterbalance to the debugging problem mentioned earlier.

Customization

Ionic 2 stands out by its themes, a way of customizing projects in a flash. Creation starts with a default Light theme and is modified by SASS. This is incredibly useful when you aim to launch the same app on multiple platforms and want the app to blend in with the general feeling of the environment it runs in. The development theme has already announced a Dark theme and possibly more ready-made themes will follow. Until those are available, each developer can build their own.

Wrap-up: Learn & Switch

Angular 1 and Ionic 1 will still be around and supported for the time being, but it is time to dive into the new features offered by the sequel. It is a boost in performance, organization, appearance, and functionality. You can enjoy catching the errors early on and wasting less time on fixing bugs.
Yet, this is a new approach, and it is only reasonable to take some time to learn the ins and outs before diving in to create apps. A good set of recommendations is to start using Ionic 2 as soon as possible and only stick with Ionic 1 for urgent projects.