How do you handle a bug in a specific SDK version in a released application? Say for example I've reported and received notification that a bug is known in a specific version of an SDK. Say the SDK engineers fix the problem in the next release. Do I then need to check if the user is running the buggy release and display an error message that they can't use a specific feature with a bug in it because it will crash their hardware? Is there a more graceful way? Do you display an alert and tell them to upgrade to the latest SDK? Do you completely remove the feature? Advice would be appreciated.
This is phrased to be agnostic as possible, but I am asking for the purposes of iPhone application development at this time. General answers for other platforms would be nice as well.
It depends on the nature of the bug and on the nature of the platform. With the iPhone, for example, you cannot just tell the user to upgrade his or her phone. If your goal is to support iPhone version X.Y, then you will need to support the corresponding SDK; whereas, targeting browser X version Y.Z or Java version X.Y, it may sometimes be acceptable to tell users to upgrade.* Giving the impression that your application can do something only to give an error message saying that it cannot support it for that version of the platform does not make for a good user experience. If possible, try to work around the deficiency in the platform (by possibly reimplementing code that supposedly works in the SDK) and provide the feature to the user. If that isn't possible, then disable it when running on the deficient version of the platform, but be sure to remove all traces of that feature from the application (so that users don't click on a button only for it to tell them that the button is completely useless). I should add that conditionally enabling/disabling features is only sensible in the case where the feature is not essential to application; if a feature is a core aspect of the application, then you'd better find a workaround or raise the minimum requirements as it would not be appropriate to ship a deficient application to your users.
*An example where telling users to upgrade is not reasonable would be business applications, since business sys admins tend to be unusually lazy and users have no power to upgrade by themselves.
Related
I'm interested in learning Google's flutter/dart but I want to be able to create desktop x86 apps with it like with react native. Is there built in support or any 3rd party addons that I can use to make drsktop applications with flutter/dart?
I'm having a hard time deciding whether this question is off-topic or not; I won't vote to close it for now but I wouldn't be surprised if someone does (since it veers pretty close to the 'recommend a tool' type of question).
To answer your question though, the answer is sort-of for now. From the flutter FAQ:
Can I use Flutter to build desktop apps? Yes, but right now it’s not
very well supported. We’re working on making this a first class
experience. Our current progress is documented on our wiki.
The wiki is here and at the current time of this answer it has some basic information on how to set up building a flutter app for windows, mac, and linux, along with warnings that everything may change at any point and that any plugin needing native code won't work as they only contain code for iOS/Android. The flutter-desktop-embedding repository (left-over from before google officially started working on desktop embedding) is an example of how to get started but your mileage may vary as I'm not sure how up to date it is.
Basically, you could start developing a flutter app now on desktop now, but I wouldn't expect to be able to publish that app any time soon without a significant amount of work to get everything to line up properly. Also, publishing it might be difficult at least on windows, and on windows the current shell uses GLFW which isn't probably something you'd want to use in a released app if possible. I'm not from google so I can't speak as to their plans but I would guess (and hope) that there will be some sort of announcement at Google I/O about desktop embedding, but no guarantees.
So TLDR; yes for development purposes but no for deployment.
We are developing a project with a lot of functionality and module (Call, Chat, Update Feed and so on). It's deployment target is 7.0 to latest. This project has been developing since 2013. So there was a lot of bugs and old code. Recently this project is completed and ready to release in App Store.
But now we are finding some difficulties while testing it by QA. iOS changes many things according to it's version. We are struggling to check these changes in different versions.
For an example from iOS 8.3 the facebook sharing will have to implemented by their own SDK. The old SLComposeViewController is no more good. So we have to take care of it from iOS 8.3.
I just wondering if somehow we can get the list of these iOS versions where apple make changes, it would be easier for us to check the project installing those certain iOS version in iPhone. I think this type of information could be find in their developer site. If so any kind of information would be much helpful for us.
Thanks a lot in advance.
I asked very similar question couple years ago (not saying this is a duplicate!), and all I got then was - "read the documentation carefully". Unfortunately it still remains true even now, but you can get some tools to help you out.
For external libraries, I strongly recommend using either CocoaPods or Carthage. You can specify which versions you want to support and those tools do the job for you to check whether that library you want to include will be compatible with your deployment targets.
For your own code, you have to just write XCTests to verify the most crucial parts of your app or possibly the whole codebase (testing ftw) and stick with version checking. That will be slightly more zen in Swift 2.0 where you'll be able to do API checking as well with #available(iOS 9.0) { ... }.
I'm not sure if this is really what you're asking for, but here's a link to all of Apple's iOS release notes and API diffs on their developer portal. I believe it covers all major versions of the iOS SDK.
But speaking from personal experience, I would also say that the actual impact of minor iOS updates on the functionality of existing apps is usually negligible. I would focus your QA efforts on the major versions you support (7.X and 8.X in your case) and use the latest stable release versions there for testing, as those will be the versions the vast majority of your users will be using.
That said, I think it's also an excellent idea to at least briefly look into the actual distribution and adoption rates of iOS versions in your user base, and agree on sensible cut-off points. If you find, for example, that 87% of your users are running iOS 8.X, 12.5% iOS 7.1.X and only 0.5% iOS 7.0.X, you might conclude that providing explicit testing and/or support for 7.0.X users is not actually worth the effort.
There are many sites that provide you with general numbers about iOS adoption rates to give you a rough idea.
Lastly, if you feel that you've covered the (user-wise) biggest 2-3 versions in your testing, I think it's fair to push for your initial release and trust in your bug handling/update process to take care of any problems that may pop up in the more exotic iOS versions still out there. But that's of course a conscious decision you have to make for yourself.
I have an iOS app in the AppStore, built with Xcode a while ago, but I am thinking of rewriting it from scratch to iron out some bad decisions and this time use some cross-platform framework such as Appcelerator Titanium or Rhodes to add Android support also.
Is it possible for my current iOS users to seamlessly upgrade to the new version, retaining their userdata (of course a migrator is required in the new app). I think I have to retain some app identifier or other data in the new version.
Or should I create it as totally new app and let the users migrate their data (possibly using the Open in... scheme).
The downside of this is that current users must re-purchase the app, which might drive some of them away.
Is it possible for my current iOS users to seamlessly upgrade to the new version, retaining their userdata (of course a migrator is required in the new app). I think I have to retain some app identifier or other data in the new version.
In principle, it is possible. The fact that you are moving to a different development platform will not affect your ability to access data already stored by the user. In the end, it greatly depends on how you stored that data: if it is through NSUserDefaults, it will be pretty much transparent; if it is in XML/JSON files, you will need to add some XML/JSON parser to you new app (provided Appcelerator Titanium or Rhodes do not already provide one); if it is through sqlite, I know that, e.g., Titanium supports it; if it is through Core Data, maybe you will need to write some kind of converter for the existing data. But, in the end, it is definitely possible.
Or should I create it as totally new app and let the users migrate their data (possibly using the Open in... scheme). The downside of this is that current users must re-purchase the app, which might drive some of them away.
What you should take into account here is how much the new app will differ from the old one. If there is a risk of disappointing your customer base, maybe you can go for a separate version. It is clear that doing so will bother some users that will have paid for the old version. One scheme that has been applied in at least one case I know of is offering the app for free during an initial period. But whether this is sensible or not depends entirely on the prospects of your apps.
Maybe the best approach is striving for a largely improved new version, so that disappointed customers will be the least possible number, and keep the same bundle id for a seamless update.
I would suggest refactoring your current iOS codebase as opposed to rewriting it from scratch. Rewriting from scratch is almost always the wrong decision when you can refactor and clean up code as you go. It will always be harder than you expect, take longer than you expect, and often won't end up providing the benefit you expected it to. Refactoring is cheaper, faster, and safer.
In my opinion you would be doing your users a disservice by rewriting the app using cross-platform framework after they are used to a fully native app written in Objective-C. You would be doing yourself a disservice by throwing away code. Bad code can be fixed, no matter how ugly it is now.
I would suggest writing your Android app using Java and refactor your iOS app once the Android app is finished. You can provide the best experience for both platforms this way. The reason to add Android support first is because you already have a working iOS app in the store, so you're 1/2 way there already without touching a cross-platform framework. Writing the Android app should also allow you to flesh out ideas of how to refactor the iOS app.
As far as upgrading your current users, you need to keep the bundle ID the same in order for users to be able to seamlessly upgrade via the app store. Upgrading their data is also possible, but you need to provide more details on how that data is stored within your current app. If at all possible, the automatic upgrade is preferable to an Open In... scheme that requires the user to manually load their settings.
Inspired by an exchange on a recent question, I wanted to know whether there is any good reason to develop Windows Phone 7 applications that target pre-Mango models, i.e. by creating applications that target the 7.0 APIs rather than the more recent 7.1 APIs.
My impression was that because the Mango update has now been fully rolled-out, there is very little reason why anyone would have a phone with a pre-Mango OS. My guess is anyone with a pre-Mango phone probably never connects it to their computer and probably does not download applications.
Are there any good statistics on OS version demographics that can inform this decision?
I know from the analytics of my apps that there are still people out there using pre-Mango versions of Windows Phone, but as you point out, they are unlikely to be connecting their phone to their PC to perform updates or even update apps they've already downloaded (my wife for example would still be on the original shipped version if I hadn't updated her phone myself!).
With that in mind, personally, I don't see the point in creating applications now that target pre-Mango versions of the operating system. The return is highly unlikely to warrant the effort.
There isn't much of a reason to target pre-Mango as opposed to Mango as the upgrade is available to all models of phone currently, and for free.
It is worth keeping on the latest SDK for no other reason than there is no reason not to... lol, made sense in my head. Things like performance improvements, bug fixes, new features etc are all reasons to keep up with the latest, as you are likely aware.
The only reason I would target an older SDK is if a particular version of the phone OS was not available to a certain piece of hardware for any reason.
Then again, if you can make your app with the lowest common SDK, why not - it will in theory only increase your user base as backwards compatibility is enforced, over choosing a newer and not-completely-rolled-out version. You just personally suffer the older APIs and miss out on new features. However, I see this counter-point as a largely academic argument and adds little weight to the choice of older versions.
Save yourself the headache, go with the new stuff. Anyone actively using their phone enough to also use your app is likely hot on updates.
I don't do 7.0-specific programming any more since the roll out of Mango is now available pretty much everywhere I'm interesting in deploying apps. This question will rear it's head again when vNext is released (with potentially updated hardware requirements / sensors, etc), but for now I can't see much reason to target the old version.
I am developing a Netflix application for BlackBerry mobile devices. I need to make a decision as to the minimum OS version that I should develop for - depending on which I choose will have some design impacts (such as what browser field classes I can use, etc.)
What it comes down to is..should I support anything lower than OS 5.0?
I would say 4.5 and newer. see also:
OS - What market share do each of the BlackBerry models have?
OS - Which BlackBerry OS version to target for?
OS - What is the best practise in blackberry for reaching the widest range of smart phones?
I think there a few things to consider. First off, you need to have a clear vision of what you are hoping to achieve - features/functionality. Then evaluate the various API revisions, and determine which API level will provide the facilities needed to achieve your goals. Depending on the outcome of this, you may have to revise your goals. Maybe even consider using a lower API version, rolling out with a reduced feature set to help get your foot into the market, then in parallel be working on the full bells and whistles release utilizing a higher API version. But most importantly, you need to evaluate your market. The question becomes: "Does your target API provide you will enough of a potential market for your app?" But sometimes it becomes a difficult juggle, especially if you embrace the concept of "Build it and they will come" and you develop your app for the bleeding edge - waiting for the masses to arrive. You need to be sure to have the coverage in place (ie. financial, and political if you are in a large corporate environment) to survive until the day arrives. If you haven't already, you may want to look into becoming a Blackberry Alliance member. Also, don't be afraid to engage the major carriers in your market and push them a bit. They should be able to give you a bit of visibility into handset/platform penetration. Evaluate all of the variables both technical and business plan, and document it - the answer will come to you. Hope this helps.
RIM have created an official page with statistics that help you figure out the answer to this question: http://us.blackberry.com/developers/choosingtargetos.jsp
For example, as of November 2010, OS 5.0+ made up less than 50% of the market share of all active Blackberry devices, but OS 5.0+ accounts for 75% of free app downloads and 86% of paid app downloads from App World.
ON the basis of API similarities and supports i can divide os range like this
(A).<4.2
(B). 4.2< and <5.0
(c). 5.0
We deploy to 4.3, 4.7, and 5.0 with our app and that covers almost every in-market device being used today. There may be a few people still running 4.2 but not many.