Zeityer

App development, security, mathematics, games, partnership, beer, Android, Windows, Apple, iOS, Swift, Objective-C, Java, .NET, C; posts by Pete are - P, Tim are - T.

[zeityer]

Circular progress timer/bar in iOS using SpriteKit

Before I started, I thought this would be a walk in the park. But creating a circular progress bar/timer using SpriteKit took a bit longer than I'd like to admit. I’m not sure if it was pure naivety, or my google’ing skills starting to fail me (hopefully not!).

Anyway, after a bit of hacking around and trying various things, the following custom class proved to be a worthy solution:

import SpriteKit

class CircularProgressNode : SKShapeNode {    private var radius: CGFloat!    private var startAngle: CGFloat!

   init(radius: CGFloat, color: SKColor, width: CGFloat, startAngle: CGFloat = CGFloat(M_PI_2)) {        super.init()

       self.radius = radius        self.strokeColor = color        self.lineWidth = width        self.startAngle = startAngle

       self.updateProgress(0.0)    }

   required init(coder aDecoder: NSCoder) {        fatalError("init(coder:) has not been implemented")    }

   func updateProgress(percentageCompleted: CGFloat) {        let progress = percentageCompleted <= 0.0 ? 1.0 : (percentageCompleted >= 1.0 ? 0.0 : 1.0 - percentageCompleted)        let endAngle = self.startAngle + progress * CGFloat(2.0 * M_PI)

       self.path = UIBezierPath(arcCenter: CGPointZero, radius: self.radius, startAngle: self.startAngle, endAngle: endAngle, clockwise: true).CGPath    } }

So, if you’re using an SKScene, you can create an instance of the above CircularProgressNode class with your desired radius, colour, width, and start angle (don’t forget to set the position and zPosition, and then add as a child). Then to animate, call the updateProgress function from within the update function of your SKScene.

Now, I feel it’s my responsibility to let you know that SKShapeNode is not all that popular amongst iOS developers. One reason being that it can cause memory leaks. So you’ll need to take this into consideration if you decide to use the above code.

Check out the following SO post for some more information on the memory leak issue:

http://stackoverflow.com/questions/20292318/why-does-creating-and-removing-skshapenode-and-sknode-repeatedly-cause-a-memory

Good luck, and happy coding! :)

-P

[zeityer]

Adding an existing Xcode project to a BitBucket repository

What you’ve got:

A local Xcode project

A newly created empty BitBucket repo

What you want:

Your local project (1) stored remotely in your Bitbucket repo (2)

There are two main ways to do this: visually or via the terminal.

Via the terminal

For the command line aficionados amongst you, open a terminal window, navigate to the project directory (the one with the .xcodeproj file in it), and run the following two commands (replacing the UserName and RepoName with the appropriate values):

git remote add origin [email protected]:UserName/RepoName.git

git push origin master

And that’s it!

Visually

If however, you’d prefer the visual approach, then the first thing we need to do is add the remote. In Xcode go to the Source Control menu item, <ProjectName> - master, then select Configure <ProjectName> ...

In the window that pops up, select the Remotes tab, click the + button, and the Add Remote ...

Another window will pop up where you have to enter the details of the remote. You want the Name field to be origin (this should be the default). Then enter the address of your bitbucket repo like below, replacing the UserName and RepoName with the appropriate values.

If you’re unsure of the exact wording of either your user name or the repo name, then you can hit the Clone option in BitBucket. It’ll give you a string you can copy, just be sure to remove the git clone text at the start of it.

The final step is to push your local files to the remote. In the Source Control menu hit Push...

You’ll be asked to confirm pushing to origin/master, to do so just hit Push

You now should be able to see your local project files in your BitBucket repo! Nice :)

Note, to keep this as succinct as possible, I’ve made a few assumptions on your setup (e.g. you have a local git repo created). So, if you have any problems, these SO posts may be of use:

http://stackoverflow.com/questions/19495141/add-local-repo-for-existing-xcode-5-project

http://stackoverflow.com/questions/13048197/how-do-i-add-an-existing-xcode-4-5-project-to-bitbucket

-P

[zeityer]

iOS Swift regex matching only letters

The problem: how to check a string to see if it consists solely of letters (lowercase/uppercase/both). Simple right, just a little regex with some form of [a-zA-Z] in the guts. Unfortunately not, due to some of those pesky unicode characters, the A through Z check simply won’t cut it when your app is localised in most languages.

The solution: TLDR, just do this

static func consistsSolelyOfLetters(string: String) -> Bool {        return string.rangeOfString("^\\p{L}*$", options: .RegularExpressionSearch) != nil    }

However, if you’d like to see how manual entry induced boredom motivates an over-solving of the problem, then read on.

First comes the light reading about the NSRegularExpression class

https://developer.apple.com/library/mac/documentation/Foundation/Reference/NSRegularExpression_Class/

Then, the usual foray into SO

http://stackoverflow.com/questions/3617797/regex-to-match-only-letters

Culminating in a deep dive into the old school style data dump given to us by the kind folks at unicode

http://www.unicode.org/reports/tr18/

Finished all that? Good. So, I thought that a neat solution might be in the form of an extension on String. We can get started on it by creating a few helper variables:

import Foundation

extension String {

   var regexPositiveMatch: String { return "\\p{\(self)}" }    var regexNegativeMatch: String { return "\\P{\(self)}" }

   var regexZeroOrMoreOccurrences: String { return self + "*" }    var regexOneOrMoreOccurrences: String { return self + "+" }    var regexZeroOrOneOccurrence: String { return self + "?" }

   var regexStartsWith: String { return "^" + self }    var regexEndsWith: String { return self + "$" }    var regexStartsAndEndsWith: String { return self.regexStartsWith.regexEndsWith }

   var regexRepeatedAll: String { return self.regexZeroOrMoreOccurrences.regexStartsAndEndsWith }

}

Next, for the sake of verbosity, let’s throw in a nice enum:

enum UnicodeGeneralCategoryProperty {    case Letter, UppercaseLetter, LowercaseLetter

   func regexPositiveMatchString() -> String {        return self.abb().regexPositiveMatch    }

   func regexNegativeMatchString() -> String {        return self.abb().regexNegativeMatch    }

   private func abb() -> String {        switch self {        case .Letter:            return "L"        case .UppercaseLetter:            return "Lu"        case .LowercaseLetter:            return "Ll"        }    }

   private func longForm() -> String {        switch self {        case .Letter:            return "Letter"        case .UppercaseLetter:            return "Uppercase Letter"        case .LowercaseLetter:            return "Lowercase Letter"        }    } }

And finally, what we’ve been waiting for, we create the core logic by adding the following to our String extension:

private func doesMatchRegex(regex: String, range: Range<String.Index>? = nil, locale: NSLocale? = nil) -> Bool {        let options = NSStringCompareOptions.RegularExpressionSearch        return self.rangeOfString(regex, options: options, range: range, locale: locale) != nil    }

   var isAllLetters: Bool {        let regex = UnicodeGeneralCategoryProperty.Letter.regexPositiveMatchString().regexRepeatedAll        return self.doesMatchRegex(regex)    }

   var isAllUppercaseLetters: Bool {        let regex = UnicodeGeneralCategoryProperty.UppercaseLetter.regexPositiveMatchString().regexRepeatedAll        return self.doesMatchRegex(regex)    }

   var isAllLowercaseLetters: Bool {        let regex = UnicodeGeneralCategoryProperty.LowercaseLetter.regexPositiveMatchString().regexRepeatedAll        return self.doesMatchRegex(regex)    }

Did somebody say unit tests? That sounds like an awesome chance for some more lovely procrastination! We can create the following class in our Tests project (remembering to check the little “Target Membership” box on our extension).

import XCTest

class StringExtenstionsTests: XCTestCase {

   private let lowercaseLetters = "aàáâäæãåābcdefghijklmnopqrstuvwxyzžźż"    private let uppercaseLetters = "AÀÁÂÄÆÃÅĀBCDEFGHIJKLMNOPQRSTUVWXYZŽŽŻ"

   func test_isAllLetters_true_empty() {        // ARRANGE        let string = ""

       // ACT        let actual = string.isAllLetters

       // ASSERT        let expected = true        XCTAssertEqual(expected, actual)    }

   func test_isAllLetters_true() {        // ARRANGE        let string = lowercaseLetters + uppercaseLetters

       // ACT        let actual = string.isAllLetters

       // ASSERT        let expected = true        XCTAssertEqual(expected, actual)    }

   func test_isAllLetters_false_containsNumber() {        // ARRANGE        let string = "1" + lowercaseLetters + uppercaseLetters

       // ACT        let actual = string.isAllLetters

       // ASSERT        let expected = false        XCTAssertEqual(expected, actual)    }

   func test_isAllLetters_false_containsSymbol() {        // ARRANGE        let string = lowercaseLetters + uppercaseLetters + "!"

       // ACT        let actual = string.isAllLetters

       // ASSERT        let expected = false        XCTAssertEqual(expected, actual)    }

   func test_isAllLetters_false() {        // ARRANGE        let string = lowercaseLetters + "1!" + uppercaseLetters

       // ACT        let actual = string.isAllLetters

       // ASSERT        let expected = false        XCTAssertEqual(expected, actual)    } }

Well I guess it’s time to get back to work. Kudos for hanging in there. Hmmmm ... I wonder what would happen if we threw some emoticons into the strings ... 😏

-P

[zeityer]

Wonderfully Weird Words ... Wow

In honour of the release of our app Synonymous (a word matching game available on iOS https://itunes.apple.com/au/app/synonymous/id989615338?mt=8 and Android https://play.google.com/store/apps/details?id=com.zeityer.synonymous), we bring you a list of some of the wonderfully weird words you may encounter while playing it.

Abomasum the fourth stomach in ruminants

Agelast a person who never laughs

Ailurophile a person who loves cats

Bardolatry excessive admiration of William Shakespeare

Basorexia an overwhelming urge to kiss someone

Batrachophagous feeding on frogs

Borborygmus a rumbling or gurgling noise made by the movement of fluid and gas in the intestines

Bromidrosis fetid or foul-smelling perspiration

Callipygian having buttocks that are beautifully proportioned

Camisado an attack by night

Cereology the study or investigation of crop circles

Dactylonomy the art of counting on the fingers

Defenestrate to throw someone (or something) out of a window

Eccedentesiast a person who fakes a smile

Entomophagy the practice of eating insects

Flews the pendulous sides of the upper lip of certain dogs

Frankenfood genetically modified food

Googol 10^100, the figure 1 followed by 100 zeros

Gymnophoria the sensation that someone is mentally undressing you

Hamartithia being likely to make a mistake

Lethologica the temporary inability to remember a word

Logomachy an argument about words

Merkin a pubic wig

Misocapnist one who hates tobacco smoke

Movieoke a form of entertainment where people take turns speaking movie dialogue while a subtitled silent version plays in the background

Mytacism excessive and/or wrong use of the letter m

Nidorosity belching with the taste of undigested meat

Poecilonym a synonym for synonym

Quomodocunquize making money in any way possible

Recumbentibus knock-out punch

Sabrage a technique for opening a Champagne bottle with a saber

Sciapodous having big feet

Tarantism a psychological disorder characterized by an extreme impulse to dance

Ulotrichous having woolly or crisp curly hair

Vigesimation the act of putting to death every twentieth man

Xylopolist someone who sells wood products

Zoanthropy the delusion that one has become an animal

[zeityer]

Adding Core Data to an existing Swift project

Forgot to check that little “Use Core Data” box when creating your Swift app? Don’t worry, the steps below show just how easy it is to add Core Data to your project.

1. Add a “Data Model” to your project:

File -> New -> File ...

iOS -> Core Data -> Data Model -> Next

You can name it whatever you want. The default name used if “Use Core Data” was enabled is the project name. I suggest using this for consistency, and because it slightly simplifies a later step. Either way, note down what you called it.

2. The rest of the changes take place in the AppDelegate.swift file, so go ahead and open that up.

3. Import the CoreData library by adding the following line of code to the top of the AppDelegate.swift file:

import CoreData

4. Add the below code to the bottom of the AppDelegate class (this is basically what gets automatically generated for you if you enabled the “Use Core Data” option when creating the project):

// MARK: - Core Data stack

   static let projectName = "myProjectName"    static let dataModelName = "myDataModelName"

   lazy var applicationDocumentsDirectory: NSURL = {        // The directory the application uses to store the Core Data store file. This code uses a directory named "com.example.myProjectName" in the application's documents Application Support directory.        let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)        return urls[urls.count-1] as! NSURL    }()

   lazy var managedObjectModel: NSManagedObjectModel = {        // The managed object model for the application. This property is not optional. It is a fatal error for the application not to be able to find and load its model.        let modelURL = NSBundle.mainBundle().URLForResource(dataModelName, withExtension: "momd")!        return NSManagedObjectModel(contentsOfURL: modelURL)!    }()

   lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator? = {        // The persistent store coordinator for the application. This implementation creates and return a coordinator, having added the store for the application to it. This property is optional since there are legitimate error conditions that could cause the creation of the store to fail.        // Create the coordinator and store        var coordinator: NSPersistentStoreCoordinator? = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)        let url = self.applicationDocumentsDirectory.URLByAppendingPathComponent(projectName + ".sqlite")        var error: NSError? = nil        var failureReason = "There was an error creating or loading the application's saved data."        if coordinator!.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: nil, error: &error) == nil {            coordinator = nil            // Report any error we got.            var dict = [String: AnyObject]()            dict[NSLocalizedDescriptionKey] = "Failed to initialize the application's saved data"            dict[NSLocalizedFailureReasonErrorKey] = failureReason            dict[NSUnderlyingErrorKey] = error            error = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict)            // Replace this with code to handle the error appropriately.            // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.            NSLog("Unresolved error \(error), \(error!.userInfo)")            abort()        }

       return coordinator    }()

   lazy var managedObjectContext: NSManagedObjectContext? = {        // Returns the managed object context for the application (which is already bound to the persistent store coordinator for the application.) This property is optional since there are legitimate error conditions that could cause the creation of the context to fail.        let coordinator = self.persistentStoreCoordinator        if coordinator == nil {            return nil        }        var managedObjectContext = NSManagedObjectContext()        managedObjectContext.persistentStoreCoordinator = coordinator        return managedObjectContext    }()

   // MARK: - Core Data Saving support

   func saveContext () {        if let moc = self.managedObjectContext {            var error: NSError? = nil            if moc.hasChanges && !moc.save(&error) {                // Replace this implementation with code to handle the error appropriately.                // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.                NSLog("Unresolved error \(error), \(error!.userInfo)")                abort()            }        }    }

5. In the code you just added in the previous step, update the projectName variable with the name of your project, and the dataModelName variable with the name you used for the Data Model you created in step 1.

6. In the applicationWillTerminate function, add the following code:

// Saves changes in the application's managed object context before the application terminates.        self.saveContext()

7. Smile! You just added Core Data functionality :)

-P

[zeityer]

Password or Passphrase? Which is the right choice?

What is a passphrase?

A passphrase is a group of words used to grant access to an environment (be it a computer system, or a clubhouse) or to decipher some encoded data.

Passphrases are used extensively in cryptography. A slightly anarchistic, but nonetheless relevant, example of this being Pretty Good Privacy (PGP). With his middle finger pointed squarely at the government, Phil Zimmerman released PGP to the world, a data encryption/decryption system based on public key cryptography. The core user-reliant component being the use of a passphrase to make sure that your private key is securely stored on your computer.

Sigmund N. Porter is regularly credited with the invention of the passphrase in 1982. However, depending on the context, you would be forgiven if you believed this honour should be given to Giovan Battista Bellaso, the creator of the Vigenère cipher in 1553.

Passphrases vs Passwords

Passphrases are better than passwords! So, now that we're starting from an unbiased position, let's examine the facts.

The two are indeed similar in their usage. However, it's the difference in their length and how they are created that sets them apart.

Passwords are generally short, eight characters give or take a few. Passphrases on the other hand are much longer, anywhere from 20 to over 100 characters. Straight away this rules out most brute-force attacks, unless you've got time to see the end of time (or at least human civilisation!).

The next difference is the ease of remembering. Unfortunately most people believe that a strong password is one that is a random mish-mash of letters, numbers, and symbols. These can be near impossible to commit to memory, so then the person writes the password on a note somewhere *facepalm*. Worse, many people think a secure password is a simple word followed by a number and symbol. If they're really tricky it may be a password written in shudder.

Our ability to recall phrases however is an entirely different story. Without going into the psychology, I don't know about you but I'll forget "*K4j1s_8#M" long before I ever forget "Helpful Panda Cuddled The Monkey Scrotum For 1 Dollar!" (I'd probably type it faster too!).

Also, if passphrases are generated properly - say, by using our app ;) - then they will render dictionary attacks useless as well.

So, it's time to ditch the outdated password and join the rest of us in the 21st century using the passphrase.

Look away ... Math!

You were warned, this section contains some math ... but hey, it comes in handy when you're trying to prove a point.

Let's take a typical password with a length of eight characters. Assume we were good and selected from the entire alphabet, both lower case (26 choices) and upper case (26 choices), all the numbers (10 choices), and common symbols (34 choices). This gives us a total of 96 choices for each character in the password.

So, the total number of combinations that a brute force attack would have to check is 96^8. If we could check one billion combinations a second, which is not too difficult for an ordinary desktop computer, the time it would take to be broken is

96^8 / 1,000,000,000 / 3,600 / 24 = 83.5 days

This may sound like a long time, but we've been overly generous with the character space, stingy with the computer power, and very harsh on the choice of attack... Notice how work and school always force you to change your password every 90 days? ;)

Now, let's look at a simple passphrase of just 5 words. And let's pick our passphrase from a dictionary with a meagre size of 10,000. That means a dictionary attack would have to check 10,000^5 combinations. This gives us

10,000^5 / 1,000,000,000 / 3,600 / 24 / 365 = 3170 years

Considering this app has a dictionary of roughly 40,000 for English words alone, as well as including upper case characters, spaces, numbers, and symbols, this result quickly becomes unmanageable to measure in billions of years.

Tips

Some general best practices to try and keep in mind for passphrase usage:

Don't write you passphrase in a book or on a scrap of paper somewhere.

If you still think you'll have trouble remembering, use a secure password store! Granted, you'll need to remember the master passphrase to get into it, but one is easier to remember than several!

Make sure you and you alone know your passphrase.

It should be long enough that it is hard to guess (by a computer and a human), but short enough that it is easy to remember.

Don't reuse passphrases! Just because yours is long and hard to guess doesn't mean computer programmers don't make mistakes. Your passphrase may be compromised by the service you're using it for. Best keep a separate passphrase for every service!

Stay away from common phrases and famous quotes.

What, you still want more?

Then you can't go passed old faithful ... http://en.wikipedia.org/wiki/Passphrase

But why should you believe us? Because Microsoft says so! http://blogs.technet.com/b/robert_hensing/archive/2004/07/28/199610.aspx

For those of us who prefer the movie over the book (don't worry, it's more of a trailer at 3 mins): https://www.youtube.com/watch?v=9ldmEbakPXk

And because there's humour in everything: http://xkcd.com/936/

For the conspiracy theorists who don't trust technology (I don't know how you made it this far), grab some dice and visit http://world.std.com/~reinhold/diceware.html

Do you want GnuPG (the GNU version of PGP): https://www.gnupg.org, for the Windows version: http://www.gpg4win.org. As at writing this, PGP has been acquired by Symantec. They sell PGP desktop software now, but the protocol is the same as GnuPG.

Last but not least, a shameless plug for our app :D http://www.zeityer.com/apps.html#passphrasegen

[zeityer]

Hey Android, has that WebView loaded yet?

We like to put info/help style sections into our apps. Hopefully not because they’re complicated, but just because we’re nice guys. This does entail displaying quite a volume of text though, which can become quite unruly when the wrong UI elements are used. To simplify our experience, we turned the to the WebView in Android.

This made styling and paragraphs a breeze (and even caused some slight nostalgia of those long lost teenage years coding in HTML). However, there does arise a very common situation of wanting to know when the content of the WebView has loaded ... funny that! And this is where this nice simple solution decides to turn into a massive pain in the neck.

Unfortunately, there doesn’t seem to be a nice way to determine whether or not an Android WebView has finished loading. So, without further ado, here’s the list of potential workarounds we've gone through in order to fix this problem:

1. Creating a subclass of WebView and overriding invalidate. This ended up being our preferred method. However, there are some rare circumstances where this method doesn’t get called when the WebView is updated.

@Override public void invalidate() {     super.invalidate();     if (getContentHeight() > 0) {         // Finished loading     } }

2. Using a WebChromeListener and overriding onProgressChanged. The downside to this approach is that onProgressChanged may be called multiple times while the URL is being loaded.

webView.setWebChromeClient(new WebChromeClient() {     @Override     public void onProgressChanged(WebView view, int newProgress) {         super.onProgressChanged(view, newProgress);         if (newProgress==100) {             // Finished loading         }     } });

3. Using a PictureListener and overriding onNewPicture. This used to be the generally accepted way to go, but it’s now deprecated.

webView.setPictureListener(new PictureListener() {     @Override     public void onNewPicture(WebView webView, Picture picture) {         // Finished loading     } });

For some more perspectives, see this stack overflow post: http://stackoverflow.com/questions/4065134/is-there-a-listener-for-when-the-webview-displays-its-content?lq=1

-P

[zeityer]

Thanks Xcode, you shouldn't have

Wanting dictator like control over the UI design, combined with a noticeable distaste for GUI tools, tends to lead us away from using storyboards when we create apps for iOS. Not to say storyboards are completely useless, but they do have a time and place, and more often than not we find ourselves neither then nor there.

Being the helpful tool it is, Xcode likes to help us a few steps along our development journey by creating a few files/settings for us. Unfortunately, for those of us who want to create and control the UI programmatically, those few steps are in the wrong direction.

So, without the authors knowledge otherwise, we are reduced to completing the following repetitive tasks every time we start a new project in order to move us to step 0:

-5. Start with a Single View Application, as you can create everything from here. It's also the simplest template, i.e. the closest thing to blank/empty, meaning it's the one where Xcode creates the least amount of garbage for us to get rid of.

-4. Delete the Main.storyboard file so that the UI can be created either programmatically or with xib's. I tend to be brutal and move it to trash, but simply removing the reference will work also if that's your fancy.

-3. Delete the Main storyboard file base name property from Info.plist in the Supporting Files directory.

-2. Add the following three lines to the application(...) function in AppDelegate.swift:

window = UIWindow(frame: UIScreen.mainScreen().bounds) window?.rootViewController = ViewController() window?.makeKeyAndVisible()

The window.rootViewController is the view controller you want shown after the launch screen closes.

-1. (Optional) Add the following two properties to Info.plist:

- View controller-based status bar appearance -> NO - Status bar is initially hidden -> YES

This is to remove the status bar (the thing at the top that shows the devices carrier signal, battery life, time, ...) from the launch screen and the view controllers in the app.

If it's being a persistent bugger however, or you only want to exclude it from certain views, then try implementing prefersStatusBarHidden() to return true within the view controllers.

0. Start actually doing something.

Happy UI designing!

-P

[zeityer]

Development methodologies

Naturally, it was going to boil down to this. How is the best way to develop apps (or any software for that matter)? Because we’re focused mainly on mobile app development, language - for the most part - is easy: whatever the platform supports and preferably native. We both have our strengths (mine have been ageing well before I was born). Thankfully because of the technology, we’re not going to have a crusade over what’s better for Zeityer: Scala, Python, Ruby or Haskell… because none of those are really relevant to our work!

Anyway, I’ve digressed! We’re not worrying about languages, let’s discuss methodology. What is the best methodology for Pete and I to work on? Frankly, whatever we’re comfortable with. We’ll keep repositories private until such time as we’re both happy with them. We’ll branch if we want to add features, but merge to master promptly. We’ll chat over email, with a beer or ten, or over the phone and work out what it is we’re doing. In other words, a two-person team can achieve a fair bit more with a laissez-faire-style project management approach. (1)

Clearly this doesn’t help the purists out there - the champions of their chosen methodology - win any argument with their likely anecdotal-only evidence. Speaking of anecdotal I know people who are relatively new to the field and are gung-ho on the merits of a waterfall method of release - Gantt chart and all - and on the opposite side I’ve met seasoned developers, working in the field when I was learning sums, who might fight somebody for speaking ill of Agile. My point is, our if-it-fits-your-macros-like methodology simply just works. (2)

What about the *musts* that we can’t randomly use our favourite tools for?

We both develop on Macs. iOS development kind of needs it, and Android is Java, so platform agnostic. As for .NET development for Windows Phones? To start with we’ll need to use Windows I guess (unless we go with Mono (3)), but since Microsoft has just completely open-sourced .NET (4), I wonder how much longer it’ll be before we do it on OSX anyway?

For iOS development, we’re using Swift as much as we can and Objective-C where we can’t use Swift. Expect a blog post on my distaste for Swift, but believe it or not, our using it was mutually agreed. Testing primarily on VMs, but we both have iPhones.

For Android development, we’re using Java (big surprise). I’m working backwards on 4.1.2 on an old HTC Desire 310, and 4.4 on a Sony Xperia Z2 (my daily drive - though hopefully soon I'll have 5.0 on it... your move, Sony). We’re also making heavy use of VMs, especially as the platform is fragmented so we need to test on different screen sizes and versions from older versions to Lollipop (and beyond).

Windows, we’ll see in time (we haven’t done WinPho development yet). I’ll let you know when we do and either Pete or I can answer this then.

BitBucket is our cloud-based code repository.(5) They allow small teams to have repos for free. Also, Atlassian are Australian and we need to support the local team! Naturally, we’re using Git as a versioning system.

We’re using a Tumblr blog to ensure we’re open with the world during our progress. It’s a blog, it does its job, it’s not WordPress, and we can point zeityer.com at it.(6) Disqus adds the comment functionality to Tumblr. Reblogs are great, but there's no chance for lively discussion without the ability for comments.

I like a good wheat beer, but they’re too sweet so can’t stomach them for too long. In its absence I’ll have a pale ale or a blonde.

Hopefully that gives you some idea of what we're doing.

As an epilogue, I guess I should have a few words about my absence. You see, Azeroth needed me. #justwarlordthings (7)

-T

Have a look here for a primer on the software development lifecycle, and here to be overwhelmed with different ideas for them.

If it fits your macros is a diet fad/technique that allows people to eat whatever garbage they want as long as they meet their normal caloric intake requirements. The video is good at explaining it.

Mono is an open-source Windows .NET development platform.

Microsoft has open sourced their .NET framework! Expect it to be finalised soon!

Bitbucket.org 

While CVEs are never a great metric: Tumblr vs WordPress.

#justwarlordthings 

[zeityer]

Native vs. HTML5 vs. Hybrid

Let’s start developing apps! But how should we code them?

One of the first questions all app developers need to ask themselves is how they will actually code their apps. Ignoring the wonderful world of outsourcing, we basically have three options: Native, HTML5, or Hybrid.

Native apps are platform specific, which means the same app idea will require a separate app to be built for each operating system (iOS, Android, Windows, …). The technical implications of this being the necessity for separate code bases, being built using custom SDKs and different languages (Xcode with Objective-C and/or Swift for iOS, Android SDK with Java for Android, Visual Studio with .Net C# or VB for Windows).

HTML5 (sometimes call “cross-platform”) refers to web technology, which is mainly HTML5, JavaScript, and CSS run inside a web browser on the device. In this way, the same code can be used for the app regardless of the choice of device. However, in order to make the app available in the native app stores, a tool like Titanium (http://www.appcelerator.com/titanium/) must be used.

Hybrid, as the name suggests, is a mixture of native and HTML5. The bulk of the app is written in HTML5, which is wrapped in a native container. A popular tool available to do the wrapping is PhoneGap (http://phonegap.com).

Weighing up the advantages/disadvantages of each approach boils down to the following:

native apps providing better performance, control, and access to the features of the device

potential time saving offered by the reduced development scope of the HTML5 approach

the skill set of the developers

hybrid sitting in the middle of these points

A further consideration for some might be the extra security that comes with native code. One reason being that cached data can’t be encrypted in HTML5. And then there’s the hot topic of the security risks associated with using JavaScript (http://stackoverflow.com/questions/3793246/javascript-security-risks).

The background of the developers at Zeityer makes the native choice a pretty heavy favourite as the default approach for any new app development. In our specific case, we each have years of experience developing in the main app languages, coupled with the added sense of fined grained control and the ability to easily debug and unit test, as well as a shared disdain for web development.

This is not to say that HTML5 or hybrid apps are completely off the table. When it makes sense given the circumstance, or if we simply just feel like it, then we’ll do it. But, in general, we feel more comfortable with the native approach. And hey, if it’s good enough for Mark Zuckerberg then it’s good enough for us:

“I think the biggest mistake that we made, as a company, is betting too much on HTML5 as opposed to native” (https://www.youtube.com/watch?v=xK-7HEvfJUI)

If you’re after more information, Salesforce have written an article with a massive amount of detail on the topic:

https://developer.salesforce.com/page/Native,_HTML5,_or_Hybrid:_Understanding_Your_Mobile_Application_Development_Options

And if you’re still feeling unsure of which option to choose, and make up your mind like Ben Franklin, then take a look at:

http://www.javacodegeeks.com/2013/12/native-vs-mobile-web-vs-hybrid-applications.html

-P

[zeityer]

Travelling Salesman Problem

When you let people know you are developing apps, many of them have a similar, unique, “great” idea for an app that you should build:

“Why don’t you write an app that will tell [insert delivery company name here] the shortest route to make all their deliveries?”

Sounds like a decent idea which should be simple enough. So, naturally, the first thought is that it has already been done. After further investigation, it turns out that it has … kind of.

This problem is actually what is known in theoretical computer science as the “Travelling Salesman Problem” (TSP). A quick google on this gives close to one million results, so it’s definitely not an obscure reference. This plethora of results has a single consistent message though, which is very briefly summarised in the next few paragraphs.

In short, this turns out to be a very difficult problem. Mathematically it is what is know as an “NP-hard” problem, which basically means there is no quick or easy way of checking that a proposed solution is actually the correct (or optimal) one. Is there a quick solution? The answer to that is nobody knows. Nobody has yet been able to either find a solution, or prove that one doesn’t exist. It's actually that difficult and so popular a mathematical problem that if anyone manages to solve it the Clay Mathematics Institute will award them $1 million.

The importance of being able to check the validity of a proposed solution can be seen by examining the growth in number of potential solutions (or routes) with the number of nodes (or destinations). Without adding complexity to the problem, like the direction of the routes, some examples of the number of routes for a given number of destination are:

3 destinations has 1 route

5 destinations has 12 routes

10 destinations has 181,440 routes

25 destinations has 310,224,200,866,619,719,680,000 routes

So, checking each route to see if it the optimal one quickly becomes infeasible with modern and even futuristic computing power. All hope is not lost though, as there exist many alternative and heuristic approaches to solving the problem within a reasonable time.

Taking one of these alternative solutions and integrating with a common map provider (Google Maps for example) could be a possible app development approach. Unfortunately (or fortunately), some very smart people at MIT have created an open source product called OptiMap which does exactly that. Not to mention countless others doing a similar thing.

This is not to say that there isn’t a niche that hasn’t been found yet waiting to be filled. Just that monetising a travelling salesman app requires some consideration to be given to the difficulty of the problem as well as the current saturation of the market. In particular, the competition will consist of a large number of academics whose job it is to try solve this problem without any desire for monetary reward. 

You can find more information at:

(obvious wikipedia reference)

http://en.wikipedia.org/wiki/Travelling_salesman_problem

(youtube video series)

http://www.youtube.com/watch?v=-cLsEHP0qt0&list=PLxH6ufuE9gKtM5-bbFMTp_1-avAN-iuiq

(paper)

http://web.ist.utl.pt/~ist11038/CD_Casquilho/TSP1992EJOR_Laporte.pdf

(wolfram reference, as this is a math problem)

http://mathworld.wolfram.com/TravelingSalesmanProblem.html

(link to the Millennium Problems if you think you have the solution and would like one million dollars)

http://www.claymath.org/millenium-problems/p-vs-np-problem

(book)

http://www.amazon.com/The-Traveling-Salesman-Problem-Computational/dp/0691129932

http://press.princeton.edu/chapters/s8451.pdf

(for those that prefer the movie, where apparently the problem has been solved)

http://www.imdb.com/title/tt1801123/

(google maps tsp solver using MIT license)

https://code.google.com/p/google-maps-tsp-solver/

(travelling salesman apps)

http://appcrawlr.com/ios-apps/best-apps-traveling-salesman

-P

[zeityer]

We're now set up on Bitbucket ...

No thanks to your internet connection Tim

-P

[zeityer]

Hello Zeityer!

println("Hello Zeityer!")

-P

[zeityer]

Hello world!

helloLabel.setText("Hello world!");

-T