Category: Articles

If you have placed all git repositories in single parent folder like me. This is for you. Update all your repositories in single command.

find . -type d -name .git -exec sh -c "cd "{}"/../ && pwd && git pull" ;

and then wait for a long time… 

“He is clearly using it the wrong way!”

I have seen designers say this, when a user makes a mistake and accidentally deletes all his data. Mostly in all such cases, it is never a users fault. Designers and developers lead users to make such mistakes. If user is taking the wrong action, who is to blame? The user?

We need to understand how users navigate through interfaces we create. It can be summarised somewhat like follows,

1. User opens the app/website with some fixed goal in mind.
2. User takes a look at the screen, identifying actionable and non-actionable items from his/her past experiences.
3. User creates a virtual mind map of possible routes identified controls lead to.
4. User creates a complete route with multiple local points that reaches the end goal in his/her mind without even knowing about it. (User virtually uses the whole system before using it in reality.)
5. User travels back through all created local points back to start of the route.
6. User takes first action, that user thinks will take him/her to next local point in that route and so on.

This complete process can be further divided into even smaller steps which include deciding what kind of control it is, how to use that control etc… It is not much different from the way we navigate in the real world. Think of it as a process of a finding a route to a known location with the help of roadmaps and signs. User is crippled without these hints and markers. Also as we go on increasing number of diversions along the route, user spends more and more time processing and identifying the desired route.

Take a look at the following image specifying intentions of designer and assumption that user makes based on that,

Good design is where the designers intentions largely overlap with the users assumptions. More the overlapping area, better is the understanding user has about the system.

User interactions needs to be well thought. It is important to think in terms of Users mind map while designing interactions. We need to make sure that this mind map matches with the process intended by designers. If the designed interactions do not give helpful clues and hints, users are going to make assumptions based on what they did not understand, and these assumptions are almost always lead users the wrong way.

Creating a good interaction for users

We need to consider few points while creating a better user experience for users via good interaction design,

• Maintain clear structure and hierarchy in design

Structured information is easier to understand and process than information scattered on the screen. Know what is important in your design, group relevant controls together, create clear separation between things which are not related. If required separate out features and create collection of features that user can access on separate screens.

• Don’t reinvent the wheel

People use many interfaces and systems on daily basis. Each system makes use of the signifiers, hints to communicate with the user, May that be colours, sizes or sounds. People are used to these signifiers. They have gone through a very long learning process learning about the natural signifiers. As being designers we should not try to reinvent these signifiers, make use of existing techniques. Making your app/website distinct from other websites doesn’t mean making everything look different. Car wheels are round for a reason, don’t try to make it square.

• Provide immediate feedback

We are living in a period of technical revolution. User expects interfaces to be responsive to their input. When user takes an action, user expects the state of the information to change immediately. Sometimes it is just not possible to have the immediate change of state, in such cases we need to show activity indicators which signify that user input is accepted and being processed. Don’t keep user in the dark, let the user know that it is going to take time, its better than not giving feedback at all.

• Force user to take right actions

Sometimes use of forced constraints is required to keep users safe. There is a reason why we have zebra crossing for people to cross roads. It is a forced function to keep user from taking wrong actions. Actions which may lead system into ambiguous state should be avoided at all costs. These ambiguous state are bad because when error occurs, user has not clue what went wrong and no clue what actions to take.

We can force user to take intended actions by disabling or hiding the actions. Making a use of negative hints is also a good idea to keep user from taking wrong actions. GitHub makes use of this technique very well while deleting a repository, system makes you type in the name of the repository to delete for conformation. This is forcing the user to make correct decision.

Finally, Interaction Design is not just some fancy word, it is a medium of communication between the designer and the user. We as designers need to take that responsibility and know that almost always when user uses the system wrong way, its our fault and not users.

We typically use one of the following text search predicates with costs in terms of performance,

• Beginwith, Endswith ($)

These are the cheapest queries that are possible in case of text  comparisons. In these cases first or last few characters are checked with the text and if the match is not found, code exits. 

• Equality ($)

We can consider this query as similar to that of Beginswith, which checks all the characters in text.

• Contains ($$)

This is bit more expensive as it keeps checking for a match in whole text length.

• Matches ($$$)

This is the most expensive query in case of text comparisons, system needs to go through and work with regular expressions engine.

• Case and Diacritic Insensitivity [cd] ($$$)

This is a lot more expensive query. Lets first see what does this do. Mentioning [cd] for contains query, treats a, A, à, á, â, ä, æ, ã, å, ā as simply ‘a’. By doing this we are commanding our system not to make difference between all these characters. System has to work a lot to this comparison.

• Solution is to use canocicalized Text Seach [n] ($$)

When people search for some text, they type few characters and expect results. What we really need to do here is to use canonicalized text property. To do so we need to separate out the text that will be searched and text that will be displayed. For this we need to convert a display text with diacritic characters into canonicalized text in lowercase. Following code does the magic of converting string into canonicalized string.

NSString *str = @"àä";
CFStringTransform ((CFMutableStringRef)str, NULL, kCFStringTransformStripCombiningMarks, FALSE);
NSString *searchText = [str lowercaseString];

kCFStringTransformStripCombiningMarks is the identifier of a transform to strip combining marks (accents or diacritics).

Once we have string that is normalized form of the display text, we can apply text comparison with [n] and pass canonicalized-normalized query text. This saves lot of clock cycles that are wasted in case of case-diacritic insensitive search.

• Fetch only what is required.

Your UI can not show all the data that exists in the table anyway. Don’t put extra pressure on core data to fetch data what you are not displaying on the screen. Every app has a different requirement for performance. You need to test the performance of your app by experimenting with batchSizes and fetching objects as faults.

If you are not going to update or read managedObject relations, try using NSDictionaryResultType for fetchRequest result type. Specify which properties needs to be fetched.

• Use attribute types smartly, don’t use string for all. Numerical operations are always way faster than string operations.

In case of Predicates, always specify numerical predicates before string related predicates. String comparisons eat up way too many clock cycles, numeric comparisons are very fast.

In case of string predicates Beginswith, Endwith are fastest and Contains, Matches are costliest operations. Matches use regular expressions to perform operations.

More about string search in coming post…

• Data duplication isn’t bad in case of relationships. It makes fetching faster.
• While creating to-many relationships, make relation Cascade and Nullify.

In case of Department(to-many)Employee relation, employee to department relation should be Nullify and department to employee relation should be Cascade depending on requirements. What Cascade does is automatically deletes associated employee objects when department object is deleted, Nullify doesn’t delete objects – It breaks the relation between objects and sets relation to nil.

• Turn ON indexing only for attributes used in searching, fetching.

Indexing increases insert and update time, larger the number of insertions or updates, more is the time taken for creating indexes.

• Make use of multiple ManagedObjectContexts using parent and child relation. (iOS5 onwards)

Parent ManagedObjectContext should be of Concurrency Type NSMainQueueConcurrencyType. This is supposed to be only used for MainThread UI activities. Chile ManagedObjectContext should be made NSPrivateQueueConcurrencyType. Make larger inserts and updates on this context in background and save child context followed by parent context save. Chile context save merges changes into master/parent context and final parent context save actually writes data to sqlite file.

• Best way to delete all data is to break the complete Core Data Stack.

To delete all the data, delete the sqlite file. Its much faster than traversing and deleting each object and its relationship.

• Use multiple ObjectModels and Sqlite files when required, Its not mandatory to use only one.

If you need to delete partial data (Upon logout or some similar action), its a good idea to physically separate data which needs to be deleted. Just delete the sqlite file when you need to.

• Put Core Data Stack code anywhere but not in App Delegate, keep it as a separate object itself if possible eg. VCCoreDataStack.
• See what is happening under the hood.

Pass following arguments on launch of the app,

-com.apple.CoreData.SQLDebug 1

Pass argument 1, 2 or 3. Depending on what all data you need to see.

After UX study on previous version, We updated the screen so as to make more simpler, by removing things which were creating clutter.

Full View – http://cl.ly/image/1a0z2D2n0K3r

Saw this amazing example of bad UX today, the directory of pantaloons shop! Its supposed to be a simple map of the floors.

why does ground floor is at the top and top floor at the bottom?

Directional arrow next to ground floor suggests that if you go down, you reach the first floor!

How can people mess up such a simple thing?

Upgraded my Mid 2009 MacBook Pro 15” to 8GB DDR3 RAM and 64GB OCZ Octane S2 drive…

Faced few issues initially, system wasn’t booting up from new SSD. Tried to downgrade EFI firmware from 1.7 to 1.6. It didn’t help much.

Then updated SSD firmware to latest using firmware tools… And know what, it just works! 

Currently running ML 10.8.3 with EFI Firmware 1.7 without any issues.

Here is the link that helped a lot… 

http://www.ocztechnologyforum.com/forum/showthread.php?104990-NEW!!-OCZ-Bootable-Toolbox-Mac-Edition

Really???

Whats bad with these apps?

1. Bad Types, not at all readable on the device. Specially Kings XI punjab app!
2. Almost none of the apps really do follow UI guidelines
3. F**ked up tab bars
4. F**ked up control alignments
5. Ok I understand about having brand colour apps but still like this??? Look at RCB app, I mean really? You really want me to install that shit on iPhone?

I personally think if something needs a walkthrough maybe its time to redesign the interaction. It generally means the app is over-designed, i.e. instead of solving the problem, we are trying to delight the user more. 

Ofcourse delighting the user is must, but it should come through better usability and interaction first, and then through UI. I feel by adding walkthrough we try to make user feel that its rocket science, when it really should not be.

Mailbox app gestures originated from app… Clear. Mailbox guys took it one step further. I loved the app at first look and kept it on my home screen but few weeks later, It was clearly failing to satisfy my needs as being ToDo app, I am back to default reminder app, and Clear app is not there on my iPhone anymore. Maybe being a developer, I was amazed with quality and process with which they executed the app, respect for that was the main reason for me to keep that app on home-screen. But it didn’t last long.

Few days back, I had this awesome wallpaper on my iMac of Crysis 3 Hunter holding a gun, nicely made wallpaper with lot of thought given to detailing. Our graphic designer was passing by happen to see the wallpaper, He came towards the screen touched the screen where there were scratches on the gun, and admired the detailing…. “look at those scratches!”

The other day, I found my old iPod classic while cleaning a drawer, first ever Apple product I bought. It has a dent on the side. First thing I did was touching that dent and remembering how that dent was formed… It was nostalgic!

What do we see here, these dents and scratches are things that create negative feeling for an object but somehow they also generate positive emotions. There are numerous objects around us which are not perfect, faded old jeans with a impression near front pocket where we kept cellphones, favourite leather belt that gets better with the rough use, old tape recorder with aluminium body peeping out of the black paint through scratches. These all things generate emotions that certainly make us feel good if not happy all the time. We can identify our mobile device from similar looking other phones kept together. These imperfections make these mass produced products our personal product. Every dent has a story to tell!

Every object tells a story.

Henry Ford

We have objects in our house that are very old. As we keep using these objects, as we grow older, these objects grow older with wear and tear. They become a part of our lives. The nail-cutter we use at our home is actually older than me! I am proud of that nail cutter, I don’t keep it inside a drawer, I keep it on a table where people can see it. I tell this fact to every person who passes by it. I don’t even feel like buying a new ones that are available in market, specially designed with flowers graphics on it. Its old, doesn’t look very good but its been doing its job since very long time, It has become a part of our lives. Why do we feel great when we use or find our old stuff. We have a strong bonding with these things. It gets better with time as they grow older and older! This is the basic property which makes these objects very human. It makes non-living objects come alive. We exactly know each n every moment in this journey of that product, when it accidentally slipped of your hand and got a dent. These scratches and dents are like old photographs. They tell us a story same way as old photographs. It makes it our personal stuff as no one else knows how to read this story, with each dent and scratch it become more n more personal. It becomes an encrypted storybook full of pictures which only you can decode!

Emotional aspect is very important when you consider a design. Imagine two futuristic robots, one that never ages, and other one that grows older. Almost certainly everyone will say that the robot that ages and becomes older will generate considerable emotional response, that is the key aspect that makes a mass produced robot(futuristic!) a personal one. This is what makes every mass produced product more and more personal. One can argue that customisation will provide similar response in a design of a product. Customisations and Personalisations are very different processes. When you buy a car with some specific engine, colour etc. is a customisation and few people take this car and create an artwork on it, paint stripes, graphics, make it sound louder, tune its performance, this is what a personalisation is. Personalised products generate more emotional response than customised ones.

Every dent or scratch you have on your device tells a story, don’t curse it, you just have to try and read it for once.

Command to find out how many lines of code you wrote in a folder tree… Following example is for ObjC iOS projects.

find . -name "*.[h|m]" | xargs cat | wc -l

Everyone knows the application DrawSomething and the kind of quick success this application has seen is beyond imagination. This is the application where users can draw doodles and share with friends live. It is something very different and subtle the way you communicate with your friends live. There is human factor involved in this application. This is what i think is the key point of success. There are applications that allow you to create drawing on devices and also to share with your friends over various social networks. This just clears your table and puts a simple idea of sharing a drawing space live with friends. No hassle, no upload to server and sharing of links. Anyway you get my point!

Few events took place in last week, reminded me of my early work in around 2008 when I joined a technology company that used to focus on developing applications on handheld devices. There was no iPhone at that time. People were using ugly/sluggish windows mobile phones. The main key product for this company was a cross platform chatting application on mobile. If I am not wrong, this was the first company to introduce chatting on handheld devices. I was the very lucky one who got to work on this product. In around June 2008, I had completed almost one year working on this product and that is when an idea struck me. This product had ability to work as a platform that could allow developers to create applications (plug-ins) that can communicate over chatting network and allow users to play, share and create photos while chatting. This was a simple idea that allows developers to just ignore about how data will be communicated across devices and focus on making beautiful apps that would make use of this in-place network to share tasks.

My idea was that chatting could be considered as a simple plug-in that actually allows user to send and receive text messages. So we have a network that already does that, then why just limit ourselves on using simple text based communication? People were working on audio and video transfer using same network. Communicating does not only mean that you talk to other person, playing multiplayer game, drawing on a shared workspace etc. also are ways of communication.

I had created a proof of concept to support this fundamental idea. For almost for a month I was working on this idea, (Thanks to my TL and others who supported me while working on this RnD project). I decided to make a plug-in that would allow people chatting on any damn network to share a whiteboard for drawing live (as far as they were using same chatting application with same version plugin). I did not know if that was going to even work. After a month or so, lot of efforts on deciding a protocol of communication over IM networks, creating backend supporting engine to run plugins over the application, a time came when I was actually trying to make it run on two devices (windows mobile 5.0s), I drew a line on one device. I was looking at the other device to see something happening, I wasn’t even expecting to see line, just something on the screen to assume that something was working. I was looking at the screen, it seemed like a longest time span I had waited for something, everything moment I had spent during last one month ran through my mind like a movie. It wasn’t much time; just before 1 sec I saw something appearing on the other screen, I couldn’t believe it was the exact same line, with exact colours I chose on the other device. It was the sense of achievement I cant forget, it was the single best innovative project I worked on as a developer. Very soon it was completed I was able to draw whatever I wanted and share space, exactly the way DrawSomething app does!! (Now you get my point why I was talking about this app at the beginning of this!!)

Soon I created different plug-ins like, battleship, tic-tac-toe etc. I was happy, People were excited to see this kind of application running in reality. It was going to help third party developers create games for this chatting application. That was the main goal from business point of view. To get more visibility around the world and to allow users to play multiplayer games on handheld devices created by these third party developers. It was all going great and suddenly, the concept was killed by senior management (same management who were excited about this one).

Few days back while talking to my colleague who showed me DrawSomething application she was using, I was like “WOW” this is awesome, Finally the concept my company was hesitant to deliver was created by someone after 4 years! I am happy* its out there in the wild and people are loving it 🙂

* I have no relation with the creators of DrawSomething app. This is all there work what appears in the application. I have no intention of calling it my work. Also I don’t mean to be rude to company, whom I joined as a fresher, It was most creative period of my life. This all just needed to come out.