Sencha Touch is no longer supported. Its last version was for iOS 6! It was absorbed into ExtJS. Definitely don’t use Sencha.

I only recommend you develop in native over hybrid tools and frameworks. There are a few reasons, but here are the big two.

Money - Native is harder to learn and maintain your skills, so you make significantly more salary. Companies choosing hybrid usually don’t have the money to hire native. It makes sense.

Technology - Hybrid gets boring fast, because you can’t do a lot of fun, mobile-specific work. It’s all generic and limited. You discover road blocks in hybrid all the time.

That last one can have serious repercussions. I know of entire teams and their managers getting fired once a company needs a mobile feature, and hybrid can’t do it. That means scraping their current app and starting over with a native app. Skills the team doesn’t have.

Ever notice that developers who talk up non-native all have web skills? Or that they are talking about saving money and time? Or that they don’t talk about what happens when you have to have a native feature? When you read blogs or answers about native versus non-native, just ask yourself those questions.

Here are some thoughts from my experience working on Stay In Touch(http://www.stayintouchapp.com), which is a mobile web app that we wrapped in native iPhone/Android wrappers via Phonegap for distribution in the app stores:

Benefits of building mobile web app:
1) Just need HTML5/CSS/Javascript skills vs Objective-C or Java. We made things even simpler by using Mobl (http://www.mobl-lang.org), a domain-specific language for creating mobile web applications that compiles to javascript/html.
2) Single code base for all platforms (iOS, Android, Windows 7, mobile web)
3) Rapid testing and deployment (up until you Phonegap it, at which point you're subject to App Store review conditions, etc)
4) With Phonegap, you can still take advantage of distribution and integrated payment via the App Store or Android Market

Drawbacks:
1) Poor performance, esp if your app is graphically intense, i.e. a game. Totally in agreement with Michael above on this point. You can implement caching or leverage some 3rd party solutions (i.e. Sibblingz) for native graphics acceleration but for the most part a native app is much faster/smoother than mobile web app.
2) Lack of pre-built UI widgets, transitions, standard controls, etc. Your development time can take longer, especially if you want a polished-looking app with a native look and feel. You can try using Sencha Touch, JQ Touch, or similar tools with pre-built UI elements, but you'll probably still need to spend a good amount of time styling the app to look native.

So, should you build a mobile web app or a native one? If you're building an app that's graphically involved or involves any computationally expensive operations, go native for sure as the tools aren't quite there yet to make the job easy for mobile web apps. If you're building something fairly simple and you don't need any native styling or design polish, go the mobile web route.

I think the number of people who have programmed substantial apps in both SproutCore and Sencha Ext JS is pretty tiny, so I think that if you're looking for answers based on experience, you will be disappointed.

Many people incorrectly believe that Ext JS doesn't support MVC: but this was recently added with the Ext JS 4 release. You can also link changes in one component to another by using Actions - which define shared behavior among multiple components.

In our survey of 1,000 of our community devs at Sencha, there was a single developer who had previously developed an app in SproutCore (compared to significant numbers who had developed in dojo, Flex, silverlight, jQueryUI, GWT, YUI).

That said, I'll stick with the things that Sencha does, and hopefully someone who has developed with Sproutcore can answer about Sproutcore. I'll cover Sencha Ext JS4 and Sencha Touch here.

When you ask people why they use Sencha they say four things: clean architecture, amazingly readable code, easily extended, looks great out of the box. Here are the main features:

1) Sencha is an Object-Oriented JavaScript framework. Iit allows you to create data stores, models, model associations and validations, and bind multiple UI views to those models via a controller layer. You can read about its MVC capabilities with our detailed guide. It also has a proper component lifecycle that handles object creation, rendering and destruction as well as component state management.

2) It has a rich layout system that allows you to nest multiple levels of UI components and have the entire app adjust for window sizing & resize events. This works consistently cross-browser. We don't believe in progressive enhancement for an app framework. People expect stuff to look the same on IE6 as it does on Chrome 10.

3) It handles the fact that components and their data can be ready at different times and it abstracts this away for you.

4) It has a rich great templating system that allows variables and recursion

5) A pretty vast collection of pre-built user interface components that can all be consistently themed with a SCSS-based CSS theming system. Touch has gestural interfaces appropriate for mobile and tablet. It's the only framework to date that properly supports multiple scrollable areas on the same screen in a way that works cross-browser.

6) A cross-browser charting/graphing package that emits SVG for modern browsers and VML for IE 8 and below..

7) And lots more stuff, like a new class management system that makes the "hello world" package size around 50k (down from the approximately 400k+ that the older Ext JS 3), as well as jQuery like basic functionality for DOM manipulation, and animation.

The Sencha community is probably the largest JavaScript community outside jQuery. We have 230k registered forum members, and regularly top 1,000 concurrent users. We have another approximately 750k+ developers who are on our doc sites.

We offer dual commercial and GPL licenses to our SDKs. The Sencha Touch SDK is free for commercial use, the Sencha Ext JS SDK is about $300 per seat. We also offer commercial developer support and we have a visual designer for Desktop.

Alright, let’s talk about Progressive Web Apps (PWAs) vs. Native Apps—because while PWAs sound like the future, they still have some roadblocks.

PWAs are basically websites disguised as apps. They load fast, work offline, and don’t need an app store. Sounds great, right? But before you ditch native apps, let’s talk about the limitations of PWAs that might make you think twice.

1. Limited Access to Device Features – No Deep System Integration

PWAs run in a browser, which means they can’t access everything on your phone. Native apps, on the other hand, can dig deep into system features like:

❌ No full Bluetooth support (bye-bye, smartwatch syncing)

❌ No advanced camera controls (think high-end filters or AR features)

❌ Limited background processing (PWAs can’t run heavy tasks in the background)

So, if your app needs deep hardware access, PWA might not cut it.

2. Performance – Smooth, but Not Always Snappy

PWAs are fast… until they’re not. Since they run on JavaScript, they can’t match the raw power of Swift (iOS) or Kotlin (Android). That means:

❌ Slower animations

❌ Slight lag in complex interactions

❌ Higher battery usage compared to native apps

For casual apps (news, blogs, simple tools), PWAs are fine. But for high-performance apps (games, video editors, or anything requiring real-time processing), native wins every time.

3. No App Store Presence – Good or Bad?

PWAs don’t need App Store or Play Store approvals, which is great for developers who hate the approval process (which is all of us). But there’s a downside:

❌ No easy discoverability in app stores

❌ Users can’t “browse & install” like they do with native apps

❌ Less trust from users who expect apps to be in an official store

If your app relies on organic app store traffic, this could be a deal-breaker.

4. Offline Support is Limited – Not as Reliable as Native

Yes, PWAs work offline—but only to an extent. Native apps can store tons of data and work flawlessly offline, while PWAs:

❌ Can only cache a limited amount of data

❌ Struggle with complex offline functionalities

❌ May break if a user clears their browser cache (oops!)

For simple offline use (like reading saved articles), PWAs work fine. But for fully offline apps (Google Maps-style navigation, music streaming, etc.), native apps are the way to go.

5. Push Notifications – Not as Reliable

Push notifications keep users engaged and coming back. Native apps have full push notification support, but PWAs?

❌ Limited push notifications on iOS (Apple doesn’t fully support them)

❌ No background syncing for real-time alerts

❌ Less reliable than native notifications

If your app depends on real-time updates (e.g., messaging, food delivery, stock alerts), a native app is the safer bet.

6. Security & Privacy – Browsers Have Limits

PWAs only run over HTTPS, which is great for security. But since they rely on web technologies, they can’t match native apps when it comes to:

❌ Secure storage of sensitive data

❌ Advanced authentication features (like Face ID)

❌ Protection from browser-based vulnerabilities

If your app deals with banking, personal health data, or anything super sensitive, native apps offer stronger security measures.

Final Thought

PWAs are awesome for simple, fast, and lightweight experiences, but they’re not replacing native apps anytime soon. If you need speed, power, deep system access, or high performance, native is still king.

Now, let me hit you with some fun but serious questions:

Would you use a banking app that’s just a web page with a fancy button?

If PWAs are the future, why do big companies still invest in native apps?

Would you rather wait a few seconds for an app to load, or have it feel laggy forever?

So, what’s your pick—PWA convenience or native power?

For a vast number of apps, Sencha + PhoneGap (I'm assuming that you mean using both in combination, since you generally write your app with Sencha and use PhoneGap to get access to native APIs) are a viable alternative to native apps on iOS and Android.

Even though I work for Sencha - I have to say that there are notable exceptions: any applications that have highly dynamic graphics with lots of concurrent animations and accompanying audio. Particularly if you need high fidelity synchronization between audio and graphics. This usually means action games. HTML5 just isn't there yet. Along those lines, I believe that you need to stay fully native to use Apple's game SDK (that gives you limited bluetooth access.)

On Android, if you're excited by the new accessory SDK you should stay native - PhoneGap doesn't support that yet. In addition, HTC Android phones have bug(s) where they swallow gestures before they reach the browser, so be prepared to design interfaces without pinch/zoom, swipes etc. if you care about your stuff working on HTC. (Update: recent HTC Android updates have fixed that last problem)

This is from my experience with React-Native on iOS.

I remember the main tag line of React was Learn Once, Write Every Where so I think it's great for web developers, especially ones who worked on React before. Another major expectation is majority of app logic can be updated without native deployment.

Being a long time native developer, I found React-Native very limited and hard to work with for following reasons:

• To provide similar abstractions everywhere, React-Native UI framework is a custom rewrite of iOS native library. It is no where near the polish of UIKit. You end up with very poorly quality app unless you write a lot of native code.
• Development velocity is extremely slow because you need to adapt React-Native model to native model. You want to design your app to behave natively and Apple has made it simple with rich set of API. To keep up with the same interaction, the Javascript model become very large.
• Performance can be poor because the code run interpretably in a javascript engine (JavaScriptCore).
• The framework is changing very rapidly and sometime not backward compatible. Having to update native codes often to get the latest features can defeat the main purpose.

I still think it is a great idea and can be good to build apps where UI is less critical than business logic. You also have a huge NodeJS libraries to build non-UI code.

Sencha Touch is quite robust and has a good community following and maturity level but it also is opinionated in its approach. That might not augur well for the future as Web is changing day by day and the transition from the class based approach to the module based approach in recent web development and the fact that big players in the digital technology market have sunk their teeth into providing developers with various tools, task runners, package management systems etc which requires flexibility in the currently chosen technology stack.
The more flexible you are, the more prepared you are for the future. Then again you can't let go of all the wonderful things like AngularJS, Bootstrap etc which provides awesome features for a little compensation in flexibility but does provide ways to bridge other modules etc and in my opinion is far better than something like Sencha. Hope that helps.

In sensible times you would probably opt for JQTouch, it a mature product, it has a 3rd party book written about it and it would be easier to find people with JQTouch skills for development and support.

But fortunately these are not sensible times.The iPad has shown us that mobile computing could easily eclipse desktop computing as it is built on the same highly popular platform as the iPhone and now even the iPod.

There is a massive market in 3rd party apps which consumers are paying their own money for. Every switched on developer on the planet wants a part of the action, This seismic shift is the biggest thing since the Web and obviously harnesses the web to give it power.

My advice would be to go with Sencha Touch because despite it being new and harder to learn, it was created by David Kaneda, the person who started developing libraries for this market a year before anybody realised it was a market. Furthermore David is not still actively developing JQTouch.

A technology stack forms a critical part of creating any application whether it is for the web or for the mobile platform. The term is often used to refer to a combination of programming languages, tools, and software behind a development project.

The tech stack for your mobile application is quite like the skeleton made up of frameworks, languages, and software products that is the very foundation of the final product.

1. Frontend Development

Frontend development is essentially the interface of the mobile app used by the app users to interact with and navigate through the app. There are multiple tools and platforms available which help develop the front end of a mobile app. The knowledge of which tools work the best for a particular task and mark the difference between developing a site that will falter or get hacked and a site that is designed well and is scalable. The primary tools used for front-end development include:

• HyperText Markup Language – HTML
• Cascading Style Sheets (CSS)
• JavaScript
• WebAssembly

A frontend developer has two major points in consideration while developing any project – accessibility and performance. There are multiple mobile devices including multiple types of smartphones and tabs which is why it is important that the designers make sure that the app looks consistently great in devices of all sizes and resolutions. The performance goals primarily are related to the render time, HTML, CSS and JavaScript manipulations so that the load time is lowered.

2. Backend Development

Backend development is a critical part of mobile app development that is responsible for data storage, security and business logic. The backend of a mobile app is quite like a server for mobile apps because it stores and sorts all the important information that the end users do not see. In general, not all mobile apps need a backend, but increasingly a number of apps are now beginning to incorporate a backend as a typical development for mobile apps. This is primarily because of some of the new features that may require storing and sorting critical user or company-based information.

The basic backend development tools you need for mobile apps include – language and frameworks, web servers, database management systems, microservice platforms, local development environments, collaboration services, and website performance testers.

3. Development Platform

A development platform or particularly a mobile app development platform (MADP) is a kind of software that lets businesses create, test and launch their mobile apps in a short time for smartphones and tablets. It is possible to create a mobile app development platform on your own, but many organizations also buy a third-party product for the same.

React Native is an open-source JavaScript framework introduced by Facebook for mobile application development. Today many big giants are using React Native such as Skype, Instagram, Facebook, Vogue, Tesla, & UberEats so on.

In today’s scenario, developers used the React Native framework for the development of native apps with iOS, Android.

Let’s dive into various features and limitations of the React Native framework are as follows:

Top Features of React Native

1.UI Focused

2.Community

3.Live Reload

4.Tried and Trusted

5.Development Time

6.NPM for Installation

7.Programming Language

8.Mobile Environments Performance

Limitation of React Native:

1.Abstraction Layer Limitations

2.Custom designs in native language

3.Dependency on Third-party libraries

4.Complex iOS app development in React Native.

5.Cross-platform, but often requires native developers

6. No support for parallel threading or multiprocessing

7.The same components might behave differently in react native

Sencha is a green tea. It is the number one tea drank in Japan..

The colour is bright green tea. It is also caffnated. 75% to coffee which is 80% it used in ceremonially , matcha green teas are the best because tea is lighter. It is complicated to brew sencha matcha. This tea does not brew well if boiling water is used. Therefore for best it needs near boiling water by pouring first in to cups and then pouring into tea pot and with green leaves or powder matcha green tea.

If boiling water is poured over sencha leaves the tea would taste bitter. In ceremonies it is usually used powder matcha sencha. Here the leaves are included. And the tea will look yellowish. If leaves used than the usual brewing time should be used so the tea is not bitter.

I have not used the brewing time nor the way used boiling water is first poured into cups and then into tea pot.

Thank you Adrian Wan i have learnt why green tea is bitter. I shall follow the Japanese way of making green tea 🍵. And enjoy 😉 a relaxed way of making sencha tea 🍵

Sencha Touch is better than jQTouch for tablet development for a few reasons:

* It has a full layout system and independently scrollable regions. Currently it is the only JS application framework to feature these two things, which makes it ideal for tablets (where other solutions can only scroll the whole page).
* While jQTouch is still being maintained by Jonathan Stark and supported by the open source community, Sencha Touch is being actively developed by a dedicated team at Sencha.

Sencha Touch also provides much more app functionality, like data binding, templates, and MVC architecture—both a blessing and a curse, as it can have a steeper learning curve.

Benefits of Native App Development

We should cover the numerous positive sides to local application advancement:

Smooth work, quick working rate, and immaculate execution. The local versus crossover application is worked for a particular OS and makes the most of the handling velocity of the gadget.

Extraordinary plan and client experience prospects. For example, the execution of complex UX/UI plans and movement

Local application UI permits clients to comprehend route inside the application all the more rapidly

Great joining with the equipment of the gadget (for example camera, GPS, telephone, contact screen)

Simple to send off in the App Store. With regards to the topic of local versus crossover applications or a portable web applications, local applications follow the OS (Android or iOS) rules totally

Better security and dependability (applications grew locally are checked and supported by the App Store)

Simple to carry out new modern highlights that the market requests (AI, VR, AR, IoT, and so on) in local versus half breed application

Capacity to work disconnected. Web association is fundamental assuming that there is relating usefulness expected for local application improvement

SDK for engineers. It gives half-prepared, routinely refreshed arrangements and libraries that collaborate appropriately with a given working framework.

Advantages of a Native App Development

To begin, it is imperative to comprehend when it is ideal to pick local application advancement. By and large, it is right now a famous arrangement picked by some notable applications. Local application models are Google Maps, LinkedIn, Twitter, Telegram, PokemonGo, and so forth. These models have both local Android and iOS applications.

Since a cell phone is, normally, with us each second, the assumptions for its activity are high. It has been uncovered that around 80% of customers will attempt to utilize an application just a single time, and, surprisingly, the smallest application underperformance will probably put future use down.

Along these lines, assuming you intend to create an application in a cutthroat area, the choice is to go with local application advancement. Too, assuming you have an application thought that is special and for which the specialty is free, the local versus mixture application approach offers some incentive straightforwardly from the beginning.

In this situation, the formation of an MVP (the primary variant) is an extraordinary choice. It ordinarily requires 3-6 months to make a safe local application with a decent plan and top application execution. Also, consider the stage on which to assemble your application: iOS, Android, or both, concerning the spending plan and business technique.

When you get client criticism, you can without much of a stretch change, adjust, alter the local application, and add more elements in light of market needs. This assists with keeping straight with mechanical headways and progress.

To sum up, it is prudent to pick local application improvement:

at the point when high application execution is vital

to stay aware of rivals in occurrences of comparable application thoughts or markets

when the application market specialty is vacant, begin with an extraordinary first item form (MVP)

whenever the time is your ally and it is feasible to design everything ahead of time and stand by a half year before a local application send-off

if you intend to scale and refresh the application consistently