Mac Samurai

Reecently Phillip Bowden wrote about what makes a good gesture on iOS. Having seen how my mom uses the iPad & seeing what guestures are natural & easy I thought i’d do a semi response & my own thoughts post.

I agree that there are 2 classes of gestures. There are guestures that are really easy to get and ones that aren’t very obvious.
The problem as I see it right now is while we have some standards for what gestures should mean right now. Theres no standard to say that swiping right on a table view row should mean something, while swiping left on that same row should mean something else across all apps. We do have general standards for how iOS apps should be broken down into sections to make the UI easily discoverable and adhere to good UI guidelines.

In his post Phillip covers TweetBot which I think is an excellent example of some easily discoverable gestures and some not so discoverable ones. I like Tweetbot because the easy gestures cover the most used functions, while the not so easily discoverable gestures are generally more advanced features.

Think about it in a twitter client the most common things you do are (1) Check your timeline view for new tweets (2) Reply to tweets and (3) retweet other peoples tweets. You launch the app to check new tweets and reply & retweet are functions exposed as buttons when you just tap a tweet.

The other guestures which aren’t as obvious or as easily discoverable (swipping left and right to see the conversation chain and replies to a tweet) aren’t used as much by a normal user because they may not be even expecting to be able to swipe left or right on a table row. The good thing about this is really since the average user may not be expecting to be able to do these gestures, they don’t get in the way at all. But if a user does discover them then users may really appreciate being able to do that.

What though would these do in an application like Mail.app? Or an application displaying Cooking Recipies? Should we expect to be able to swipe left or right on any table view row? Its interesting though that TweetBot makes a compromise in just tapping a row which normally you’d expect to just push a new view onto the stack and animate in. Instead it expands the row vertically to show you a row of buttons of which if you want to you can tap one to bring up the tweet detail view.

I think if any application wants to pull off something like what TweetBot does you are going to have to carefully think things through to make sure that the common actions are linked to the most used gestures and the not so commonly used features are linked to the gestures not so easily discoverable.

I think I saw a tweet or a blog post explaining the tweetbot gestures for swipping left or right and holding down on a row to expose some more functions like translation for example. I think we as a community are going to have to see how more and more iOS apps use these gestures for good or bad effect and how they can fit in to different types of apps. I wonder if I would have figureed out if they were there if I had never read about them.

I think its interesting to see how Sparrow for iOS has used the same gestures for different things. While you can swipe from right to left to bring up a series of action buttons for doing various actions to the specific email, holding down on an email appears to change it form read to unread or vice versa. Swipping left to right actually slides a view away to reveal different email accounts.

Both TweetBot and Sparrow have excellent use of gestures, but  they both use the same gestures in completely different ways that are appropriate for each app, but at the same time this forces you to learn what each gesture means on each app, which could be confusing to many users.

I am not saying any of these apps are bad apps, but I say these things to make note of them. I honestly love both apps, because while the gestures are different for each one they both make excellent use of guestures and that makes them better apps than ones that just didn’t do anything with swipping left/right on a row or holding down at all.

I think we are still in the Wild West era of gestures and its going to be a while till we figure out what makes a good gesture vs a bad one. I do agree with patrick that in general the better a gesture directly manipulates the content it is acting on the better.

Other people have been doing this and this is something i’ve been meaning to write about for a while so I am taking a little bit to sit down and write about what I use. This is not a complete list.

Developer Tools

Xcode 4 - This version of Xcode didn’t start off so well, but has been progressively getting better as time goes on.

Instruments - If your an Mac/iPhone Developer and you don’t know what this is stop now and go to Apples website and read about it or watch developer videos on this, its awesome.

LLVM/Clang - This is a dream compiler. Its implemented as a library instead of a big singular program and licensed under a liberal license instead of a restrictive one like the GPL. This has allowed great integration with Xcode and allowed Apple to speed up advancements in Objective-C and C to make things that were never there before.

Github for Mac - this has become my go to git commit & history tool. I do all my commits through this and now its added support for partial commits. It makes it easy to commit and push my changes to github and when I need to check out repositories from github. I do go to the command line interface for git every so often, but I try and stay as high level as possible.

Google Chrome Canary - while not strictly a developer tool I use the current version of chrome canary synced to a google account to store all my bookmarks and keep my search engines saved online for a dedicated developer browser separate from my day to day browsing history. If you use Google Chrome then this browser will use a separate preferences/keychain etc. I like this because its a separate app dedicated to this one task. If you don’t use Google Chrome as your daily browser then you  can substitute Google Chrome for Chrome canary.

Code Runner - I’ve come to love this tool as a way to run small snippets of code without having to use Xcode or anything else to create projects just to try small bits of code I want to test out. It seems stupid but its very easy to ask a question about what you assume something will do and then just open this app up and quickly test that assumption. Coding it this isn’t as great as other editors, but for testing small bits of code it gets the job done.

Core Data Editor - This is the best way to quickly browse through your code data stores regardless if they are SQLite3 or whatever the format is. I started out testing SQLIte browsers to browse through core data, but this makes it easy to see/edit object attributes and see relationships between objects in the store which you’ll have a hard time with using a SQLite browser alone.

Textmate 2 - I’ve really tried to get into BBEdit, but in the end I just could not get used to the app. I may give it another shot, but ultimately I think these are just 2 different tools aimed at very different tasks and that BBEdit may not be up to what I need it to do. TextMate 2 isn’t perfect by far, but it does what I need and I know how to easily extend it with bundles.

JSTalk - Another great tool to test code and prototype it but in Javascript. Gus has done a great job with this tool, just about anything you can do in cocoa you can do in this.

Sublime Text 2 - Overall this is a really great editor without such a great preferences system. It takes a little bit of getting used to but overall the quality of this editor is really great.

MacVim - I’ve started to pick up vim and use it for more and more these days. I really am just beginning to discover its power.

HTTPClient - be able to see the full responses back you get back from web API’s.

Marked - Easy way to quickly preview any markdown document

Internet Stuff

Sparrow - I don’t know why, but i’ve been able to get to Inbox Zero and respond to email quicker with this client than any other one i’ve used, including the web UI’s.

Reeder - I hated leaving NetNewsWire, but after a while I grew to appreciate doing some reading within the app itself and not in my browser.

MarsEdit - I work on all my drafts and blog posts in this app.

Textual - for IRC

Productivity

OmniFocus - no other personal project management app remotely comes close to being as good as OmniFocus.

1Password - The best Password management app I’ve used.

VooDooPad - Great for Wiki style documents where you can easily keep a bunch of notes together.

Evernote - A pretty good note app that I use to keep more general notes on a variety of things that I would need to easily access online on my iPhone & Mac.

Acorn - my goto app for image editing.

Quicksilver - its been updated for Lion and is stable and works very fast. I was never quite able to find a replacement for it when I briefly switched away while it was in development limbo.

Misc

LittleSnapper - easy way to sort & organize screenshots

Skitch - Nice for sharing occasional screenshots & quickly annotating them

ZShell (ZSH) & Oh My Zsh - Great Shell & Framework for enhancing the shell, better than bash which is what you use on OS X by default.

Recently I ported a bunch of code written just for Mac OS X/Cocoa to iOS. Most of this code was foundation level code or code that called Core Graphics. Once I figured out how to #def away sections of code it was easy to get it working on iOS. The amazing thing was, most of this was written without knowing what was/wasn’t compatible with iOS and the vast majority of it just worked fine and compiles for iOS without issue. I did have to make some changes or not include some code on iOS…

- isEqualTo doesn’t exist on iOS so all instances had to be changed to isEqual (no biggie)

- TARGET_OS_MAC is defined on iOS so you have to use ‘#if !(TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR)’ for code you only want compiled on OS X

- NSTask and NSWorkspace obviously don’t exist on iOS so there was no way to port code that used them

- a bunch of “#import <Cocoa/Cocoa.h>“‘s got changed to ‘#import <Foundation/Foundation.h>’

- NSInteger and NSUInteger are used whenever possible throughout the code and made it easy to get some things working on iOS

- a big downside of getting some code to work on iOS was that I took advantage of SecTransform on OS X Lion which made it really easy to do things like Base64/ZLib encoding & decoding, without that suddenly I had to find some code that did that for iOS or leave it out. Right now CWURLRequest simply doesn’t support setting a Base64 encoded http authorization header because Sec Transform is missing so the NSString category isn’t there so it can’t be used by my URL Utilities which means that can’t be used in CWURLRequest.

That’s pretty much it. I hadn’t included AppKit specific things in this package so that made the work very easy. Though soon I may start including UIKit stuff as I start to work more and more with Chameleon. It targets iOS 5 and later, and no I have no plans to support anything earlier than that. Overall once I got over the big hump in my development process it was easy to support both OS X and iOS.

The Zangetsu Library is here on Github: https://github.com/Machx/Zangetsu

I got caught in a quick discussion on Unit Testing recently so I thought I’d write down some thoughts on what Unit Tests mean for me

Continuous Proof that your API’s work as desired

Unit Tests force you to prove your API’s do what you wrote them to do. You can say your API always returns X but if you write a unit test and it returns Y then you’ve discovered a bug. If you are ever in the least bit of doubt as to if you broke something you can always go and run the unit tests and see if anything failed. If nothing failed then you have nothing to be concerned about at the moment.

Documentation on how to use them

Unit tests not only test your code to make sure they work correctly they also serve as a form of documentation as to how they work. Although Unit Tests are not meant to be documentation, a side effect of testing your code means that you demonstrate how it works in the process of using it. If your unit tests are written by the person who worked on the API then you see the authors intention as to how the API was supposed to be used.

Stopping Regressions

Unit Tests stop you from ever reintroducing the same bug back into your codebase. With Unit tests as long as you have a test to cover bugs you discover in your code base its theoretically impossible to introduce that same bug back into your code again because if you ever do then as soon as you run your unit tests you’ll catch it and be forced to fix it.

Upping the Code Quality

As your code base gets more and more complex things like turning -Werror on and running the clang static analyzer and doing unit tests give you more and more confidence in the quality of your code and reducing the amount of bugs in your code base. You’ll never be able to rid your code base of all bugs unless you stop adding any features to your software and just spend forever doing line by line code reviews to rid your code of all bugs possible (like the Guy who snuck into Apple to work on the graphing calculator & had 3+ months to do this.)

That said Unit Tests are not the be all end all thing to end bugs in software and have some downsides

Unit Tests cannot test everything

I forget where I heard this, but someone once said that Unit tests should not test things like things on disk, in a database, on a network, etc… and I agree. Things like that don’t really test what your trying to test, they really test your environment which is probably not what your trying to test 99.99% of the time.

You can go overboard on Unit Testing

There is a balance to time spent creating unit tests and how much they actually make your code better. It can be tempting at times to spend a lot of time creating lots of unit tests to test any possible thing that could go wrong, but really there is a balance between how much you work on your code to how much you spend working on unit tests. At some point you start to see diminishing returns on your time spent in unit tests.

GUI’s are not easily testable

Sure there are ways to automate interacting with UI’s but as of right now I have not really seen anything that great. Maybe, I am wrong and I just haven’t found the super mega awesome framework x that makes testing GUI’s easy, but as of right now I have not seen anything that makes this easily manageable. The best UI automation I’ve seen is in instruments which is not really meant to be run with tests.

Final Thoughts

While I don’t think everything needs Unit Tests, I think every project out there could benefit from some degree of unit testing. What that degree is depends on each project to figure out for themselves.

Yeah yeah yeah I know this is gotta be a really old topic. I expressed some opinion about this on twitter, but It feels like its far to easy to sound condescending about this topic within 140 character segments when really your trying to be respectful to someone you disagree with. I recently had a discussion with Jon Buys where he said he loved and kept coming back to vi and felt like everybody should know how to use it. I replied back about my horrible experiences with it and how I just didn’t get vi’s modes.

To be specific when I first started work as tech support I was working on some old SCO UNIX boxes and inevitably we had to edit text files. One of my bosses said to launch vi and edit a text file. Before this experience I had never used vi before, I don’t know why I’d never used vi, but I just didn’t know about it or didn’t have a need to use it before this point. I believe I had used pico/nano and at least BBEdit or TextWrangler. So when I launched vi I assumed that, although it surely had a couple differences from other editors, that it worked very similarly to what I already knew. How wrong I was…

I started up vi and started to type text *BEEP* *BEEP* *BEEP* *BEEP* *BEEP* wait… what? This was such a jarring moment compared to every other text editor I had ever worked with. I start up TextEdit and you get a window and you can just start typing text right away. I start up TextMate and you get a window and you can just start typing text right away. I start up Xcode and you get a window and you can just start typing text right away if you left it on a text file. I start up BBEdit and you get a window and you can just start typing text right away. The purpose of a text editor is to allow you to edit and type text and vi has been the only text editor to get in the way of doing this task.

Instead of just allowing me to type text I have to remember to hit “I” so I get switched to the insert mode so I can begin to type text. VI’s modes feel greatly like a solution to a problem that I don’t have. It feels like vi’s modes could be a solution to some problem, but even now I fail to mentally grasp their purpose. The only thing I can think of is that they prevent you from accidentally performing certain operations in accidentally adding/deleting text. But still that doesn’t feel like a good reason for them, because any text editor with undo support this problem is irrelevant because you can just undo changes very easily. Instead of just hitting a key sequence to do a command I have to mentally keep track of what mode I am in and remember to switch between modes for certain tasks. For me this feels like a big burden to ask people to carry with them to use your editor.

Even now I just started up vi and tried to type some text and perform 1 or 2 operations and then quit. Instead of ending up with the text “This is some text.” I ended up with “this is some text jkjk^Z”. Thats another thing with vi is it feels like when things go wrong, it doesn’t quite let me know whats going wrong, I only know that it is going wrong and my editor is beeping and complaining to me. Once I started up vi at this tech support job and tried to edit some text I did edit a file successfully and then at the end when I thought I was saving a file vi felt the need to append a number I apparently accidentally hit to the end of the text file several times. One of my coworkers said “oh yeah if you hit [some key] it will do that.” I could help but think “What the fuck?! how is this helping me, how does appending text to the end of this document without my consent help me at all?”

No one text editor does everything for me. vi just doesn’t feel like it was designed well, emacs works wonderfully for me, but I just don’t need to go to it that often and I dislike having the files with “~” appended to the end of a file clutter up my directories. When I need a simple text editor that just f’ing works and just need to simply edit some text I start up nano(pico on older systems). Most of the rest of the time I use Xcode’s source code editor, I do edit some text in TextMate though I am trying out BBEdit and liking it to some degree, but as of yet I just don’t know if its for me.

In short I use whatever text editor is suited to the problem I need, sometimes its nano, sometimes its TextMate, sometimes its Xcode. vi just isn’t for me and everything that works for me, just isn’t for everybody else.

I am sending this letter to my representatives in Congress. I suggest you write one as well and send it before early September when Congress meets to amend the current Patent Reform Bill. You can use the contents of this letter if you wish, though I would strongly advise that you write an original letter if you can.

=============================================

Dear [Congressman],

I wish to write to you on a matter of great importance to the United States. Our Patent System is tremendously broken, and if we do not take steps to fix it this will lead to a significant loss of tax revenue as software developers withdraw their software from sale within the US and a loss of tech talent as more and more developers flee the US because of not wanting to deal with the broken US software patent system. There is already a movement within the software development community to recommend against including obvious features in software that are currently under litigation. Some are actively beginning to recommend against selling software in the US because of patent threats.

Congress is working to pass S.23 and H.R. 1249 to reform the patent system. Unfortunately, these bills as they currently stand do not protect companies from damages against Non Practicing Entities (NPE) which many in the software industry refer to as Patent Trolls. We refer to them as patent trolls because these companies make no actual products. All they do is buy or acquire patents and use them to sue everybody who they perceive as violating it. These companies you never know are there pop up and demand you pay them because they believe your products violate their patents. Because these patents are so broadly worded everybody can be said to violate the patent. If I was ever sued, and even if I knew with 100% certainty that the patent was invalid, I would definitely lack the funds to fight the patent in court. This is because the burden is on me to invalidate the patent by paying millions of dollars out of my own pocket, and even then there is no guarantee that I would win If I ever did find sufficient funds.

I strongly encourage you to amend any of these bills to include limited damages against NPE’s. Many in my industry would even go so far as to recommend abolishing software patents entirely, but at the very least these NPE’s need to be brought under control. Many companies are being put out of business and those who do survive patent attacks lose out on a lot of money that could be spent to hire more employees and buy resources to expand their business. There is even the possibility that many of those same companies may have to withdraw their products from the market.

This is not a time when we can afford to let companies with no actual employees who hire many lawyers purely to sue others hinder progress and innovation in the United States when we really need to be expanding and trying to grow our businesses. All I want to do is work hard on my software products, put them up for sale at a good price and try to earn a honest living from them. Unfortunately it disheartens me every time I see a patent troll sue one of my colleagues for patents that are obviously invalid and should never have been issued in the first place.

Colin Wheeler

Today Google lashed out against the winners of the Nortel Patents and went on the offensive assuming these patents were going to be used against them. The Patents went to a bunch of companies including Apple & Microsoft. According to NPR’s When Patents Attack Episode Google wanted the patents purely to defend themselves. It then seems strange to automatically assume others would use those patents specifically for attacking Google. Some of the patents may actually eventually be used against them at some point, but I doubt that was their primary intention when buying the patents. So their reaction kinda seems almost a little paranoid.

I can’t say I really believe them at this point. I know Google doesn’t like patents, nobody in the software industry really likes patents. But Google seems to be right about not liking them for all the wrong reasons. They appear (in public) to only care about themselves. Still as of today Google has yet to publicly say or do anything for any of their Android developers when it comes to patent attacks especially from Lodsys. Apple in comparison as done at least a couple things. Apple sent Lodsys a letter telling them that their issue shouldn’t be with iOS Developers but with Apple since iOS Developers are using their API’s and services (via the App Store.) Then Apple requested to intervene in the patent lawsuits against iOS Developers. At this stage its not a lot, but Apple has publicly spent employee time, money & resources at least doing something for their iOS Developers under threat because of their API’s/services.

The frustrating thing in all of this is there must be employees at Google raging and angered about patents being used against them and against Android Developers. That they hire and have employed many Linux developers who tend to not like patents must mean this is a significant issue to them. However nothing has come out publicly from Google regarding patents used to harm their Android ecosystem or their 3rd Party Android Developers until they felt themselves to potentially be under direct threat from Patents. I don’t know if Google themselves feel because of contractual obligations they can’t do much, and it is very possible that Apple is under the same contract and can really only do so much and it’ll turn out that in the end they can’t do anything. Google has, in comparison, done nothing… nothing (at least publicly.) Geeze Google at the very least you can send a very strongly worded letter to Lodsys telling them to go fuck themselves and to please leave your Android developers alone. I have no idea what Google employees are thinking that they are literally not doing anything at all.

Even stranger is that according to Brad Smith of Microsoft on Twitter, Google was invited to join the pool of companies biding on the Nortel Patents and they declined. Again from a very public point of view Googles actions seems incredibly strange and to not make any sense at all. Google please for goodness sake, do anything… anything publicly at all to show you at least give a slight shit about the software patent issue beyond it directly affecting you specifically.

The US Patent System is severely broken when it comes to software patents. This latest incident involving Lodsys really just exposed how broken the system is. This is all just my personal opinion and I cannot stress enough that I am not a Lawyer.

There are several problems with the system as it is now

(1) Smaller companies are effectively cut out. Small companies can’t afford the funds to pay $15,000+ for each patent filed and that doesn’t even count all the resources you’d need to seek out people infringing on the patent and then additionally get them to pay you or sue them for infringing your patent(s.)

(2) There is no incentive to see if you are infringing. Now I am not a lawyer, but last time I read up on patent law if it is proven that you researched patents and knowingly infringed then its 2x damages. So our system encourages everybody except for the massive corporations like Apple, Google & Microsoft to never research to see if they could possibly be infringing on patents.

(3) Obvious patents are awarded. In an episode of Security Now! Steve Gibson discussed a patent Microsoft filed for in which they were patenting a system to make e-ink flow smoothly. When you get into the meat of the patent it turns out that really the patent was for priority queues which have been around for a long time, certainly longer than Microsoft has existed. I don’t know if this was awarded or not, but it really would not surprise me to find out they were awarded it.

(4) Even if it is incredibly obvious a patent is invalid, it still takes a huge amount of money to fight it. Figures i’ve seen range anywhere from $50,000 to $1 million which is absurd. So the small companies are screwed again, they can’t afford to file patents, can’t afford to buy them from other companies and can’t afford to fight them in court even if its incredibly obvious that the patent is invalid.

(5) There is no requirement to enforce a patent. So even if a company is awarded a patent there is no requirement to enforce it, this often results in many patent troll holding companies holding on to patents for a long time while the industry builds on top of using the patent and then they strike and get companies to pay huge damages.

I personally like Marco’s analogy to prohibition, where a law intended to be noble and do good in practice turns out to have very negative consequences and in the end does more harm than good. I must admit I am torn. On the one hand the developer side of me has seen no evidence these do any good at all, but on the other hand the skeptical side of me knows that surely there must be some good that software patents have done.

Another issue is that really when software engineers violate patents really they are just engineering solutions to problems. They aren’t thinking “gosh I need to solve this problem, but not in a way that violates any possible patents.” They are thinking, hey I need to solve a problem, here is my approach and now I’ve engineered a solution to the problem. Yes in the course of engineering solutions to problems you’ll probably come up with some neat tricks, but then so will 10,000 other engineers with 100 other programming languages on many different platforms. Ultimately my overall opinion is one shared with many others. That really in the end these ideas are worthless, its the implementations that matter. You may have come up with a clever hack, but so will a thousand other engineers.

So with that in mind what do we need to do? I think one of the best solutions is twofold (1) keep obvious/invalid patents from being awarded to begin with and (2) to make it easy to invalidate patents. If you have a patent and it’s a good patent with no prior art then you really have nothing to fear from having it examined. The big point in any reform should be on beefing up the defenses of those being sued, because clearly the way our system works now, the people holding patents clearly have demonstrated that they have a sufficient amount of funds to acquire those patents regardless of the means that they used to acquire them.

Clearly the US Patent system is in bad need of reform and even the big companies like Apple, Microsoft and Google agree. Even they have problems where they stock up on software patents like the US/Russia did in the cold war and when they are sued for violating patents it usually ends up that the 2 big companies agree to cross license each others patents and avoid paying out huge damages.

This system is not beneficial for anybody except the patent troll holding comanies.