Skip to main content


Showing posts from 2017

Deals You Can't Miss

1 Year Subscription

A tale of a lone Zen Developer among Code Factories

This post is a sequel to my earlier post - Embrace and Evangelize Zen Coding . The earlier post paints a picture of who a Zen developer is. But who are Code Factories? Code Factories are those developers that take pride in churning lots and lots of code, bloating the product with features and bugs, with the vested interested of becoming a team's irreparable liability.

Embrace And Evangelize Zen Coding

A few days back I stumbled upon a tweet read something like below: The above tweet is the theme of this post. And this theme is more of a birds-eye view of software product delivery, on the state of developer maturity from business stand-point.

How to hire an Agile Consultant?

This post is a sequel to my previous post titled, " Why Agile Certification? " - that was aimed at organisations to help them figure out why they are asking for Agile Certification as a requirement in hiring candidates?

Why Agile certification?

It is understandable for trainers to hard sell Agile Certifications by way of workshops, conferences etc.

Book Review - The Subtle Art of Not Giving A F*UK

Eastern Philosophy In Western Package The author subtly evangelises a very eastern philosophy or spiritual values, by presenting it all in the very western way and that too in a very casual and conversational style. This presentation style is new and refreshing. The author spews a lot of "f*cks" in the first chapter giving the reader the highs required for him to keep the page turning. Post the first chapter the author continues his conversational style of presenting his gripping views making the reader think about it all by reflecting on his/her past experience. The need for simple but hard to practice values are reminded time and again throughout the book. And you ask what is this philosophy or values? Go grab your copy now and get enlightened!

Talk - Myth of Genius Programmer

This talk revolves around the myth that goes around in the corporate world of software development of force-identifying Heroic Geeks at varied levels starting from team to programmes to the entire company. Okay, okay, the startup world of software development is as well plagued by this myth.

Rob Pike's 5 Rules of Programming

Rule 1 : You can't tell where a program is going to spend its time. Bottlenecks occur in surprising places, so don't try to second guess and put in a speed hack until you've proven that's where the bottleneck is. Rule 2 : Measure. Don't tune for speed until you've measured, and even then don't unless one part of the code overwhelms the rest. Rule 3 : Fancy algorithms are slow when n is small, and n is usually small. Fancy algorithms have big constants. Until you know that n is frequently going to be big, don't get fancy. (Even if n does get big, use Rule 2 first.) Rule 4 : Fancy algorithms are buggier than simple ones, and they're much harder to implement. Use simple algorithms as well as simple data structures. Rule 5 : Data dominates. If you've chosen the right data structures and organized things well, the algorithms will almost always be self-evident. Data structures, not algorithms, are central to programming.

Startup Vanity Metrics

Warning: This is not for the faint-hearted. Read on at your own risk of hurting your vanity..

Android Activity's onDestroy() Ain't Your Reliable Friend

Look at the Android Activity life-cycle events in the picture beside. The lifecycle isn't something new. You're familiar with it right? You're also that good Android developer that writes clean code, wherein you consciously override onDestroy() method to include resources clean-up code and save some state, right? Per Android doc , it is okay and usually the practice to write cleanup code in this method but not anything beyond that. So if you are to write code to persist state in this method, or anything else beyond resource clean-up (like threads associated with an activity), you're better off to push it up the life-cycle, either in onStop() or onPause() method. That is how I settled in the first iteration of new learning but wasn't happy. Why? To quote Android Doc:

Android - Don't Keep Activities - Developer Options

"Don't Keep Activities" - are you aware of this must turn-on developer setting in your Android device? Not sure about you. The first time I saw this in the developer setting, I laughed out wondering why on earth a developer would want to do this, assuming that this would hide the app performance issues. I was so damn wrong. Contrary to my assumption, turning on this developer setting actually helps you identify performance issues. It helps you identify memory leaks of an activity. Where do I find this? See picture attached. How it works? When the developer option - Don't Keep Activities - is checked-on, in the device, all activities that are stopped will be destroyed almost immediately. It simulates the Android Operating System behaviour when your app is in the background and the system is short on memory; because of which it will destroy your background activities. How is it useful?  It is intended to help developers debug their apps  for testing save

Notes On Android Notification

This post is my notes drawn from Official Android Docs  and  Android O: How to Use Notification Channels . A notification is a message you display to the user outside of your apps UI. When you tell the system to issue a notification, it first appears as an icon in the notification area like below: To see the details of the notification, the user opens the notification drawer like below: Both the notification area and the notification drawer are system-controlled areas that the user can view at any time.

Book Review - The Checklist Manifesto

It's a well written book shedding light on the importance of Checklists at work even if it is very critical with regards to time, cost, size of team/project etc. The author shares stories and anecdotes on how right kind of checklists can avert serious damages/mistakes. I particularly like the way the author catches the attention of the reader in the beginning of the book. As the book gets to the later chapters, it gets dense in the domain that may or may not interest the reader. I would recommend you get your copy from Amazon for cheaper price. Have fun reading it..

When do you use map vs flatMap in RxJava?

  Learning RxJava is an overwhelming exercise because it is a paradigm shift in the way you solve your coding problems. During this learning process, of the many doubts you'll have, one such would be, "When do you use map vs flatMap in RxJava?". ProTip : Get used to understanding the Marble Diagram for understanding the basic concepts of Reactive Extensions. Here is a simple  thumb-rule  that I use help me decide as when to use  flatMap()  over  map()  in Rx's  Observable . Once you come to a decision that you're going to employ a map transformation, you'd write your transformation code to return some Object right? If what you're returning as end result of your transformation is: a non-observable object then you'd use just  map() . And  map()  wraps that object in an  Observable  and emits it. an  Observable  object, then you'd use  flatMap() . And  flatMap()  unwraps the  Observable , picks the returned object, wraps

Book Review - Scalability Rules

A book for Scalability enthusiasts A good book that should serve as ready reference or guidance for anyone interested in the topic of availability and scaleability. Even though, the guidance/rules that this book mentions, seem  simple and seemingly intuitive, in the real-world situations you'll find violating these giving whatever excuse it be. Reading books like this re-affirms our own intuition and awakens you of risks the next time you come across situations that warrants you to apply these rules where appropriate. The later chapters could have been better explained with examples. For instance, in the chapter on "Avoid or distribute scale", the author could have explained situations where these rules can be applied and where it does not. In the absence situational examples or use-cases, the reader might likely remain confused or worse with false sense of knowledge. The same applies in the chapter on async communication with Message Buseses, where the author tal

Book Review - Reactive Android programming

I read this book from SafariOnline. The book is a fantastic read, ridden with examples. The reader typically learns by example. It's a no fluff, just stuff to the point that saves you a lot of time. The book covers employing contemporary 3rd-party libraries where required depending on the use-cases, all blending well with the respective topic/situation. I'd say this book is from one pragmatic programmer to a busy, impatient and hungry programmer wanting to get his hands dirty.

Android Development ProTips To Prevent Memory Leaks

Memory Leaks are not apparent  during development This post is for those impatient Android developers who are seeking a checklist of tips to remember during development, in order to avoid the nasty Memory Leaks in the app thus leading to poor app performance. Poor app performance results in bad user experience that leads to poor ratings in the Play Store. Let's get the basics right. As much as we'd like to think of Java's Garbage Collector as our reliable agent to cleanse heap of stale objects, it's not hundred percent fool-proof, in that some of the overlooked coding gotchas can trip its reliability. For instance, a WeakReferenced object gets garbage collected quickly over its Strongly Referenced object. But that said, using WeakReferenced object comes in the way of elegant coding. So, typically you look for for areas where you can introduce WeakReference. ProTip #1: Where possible, use  the context-application instead of a context-activity. Look for oppor

Notes from TED Talk - Why do ambitious women have flat heads?

Watch it in TED Speaker Profile In 1962, Dame Stephanie "Steve" Shirley founded Freelance Programmers, a software firm with innovative work practices -- and (mainly) women employees.  She is a successful million-dollar entrepreneur, Philanthropist and a business-woman in technology.  She is author of the book (memoir) titled, " Let it Go: The Entrepreneur Turned Ardent Philanthropist " Secrets to success Surround yourself with first-class people and people that you like.  And choose your partner very very carefully. Startup Entrepreneurship It's one thing to have an idea for an enterprise. Making it happen is a very difficult thing. It demands: extra-ordinary energy, self-belief, and determination  the courage to risk family and home  a 24/7 commitment that borders on the obsessive. Work : "So it's just as well, I'm a workaholic. I believe in the beauty of work when we do it properly and in humility. Work is not just something

Colorful Android Logs for Better Productivity

This post assumes you're using Android Studio, if not you better do ;) It's very common to keep an eye on the logs in Android Studio, every time we deploy the app-under-development into a device/emulator. And it hurts our eyes and our peace for the increased attention we tend to keep on the rolling logs in the Android Studio hunting for the required pieces of information. Is there a better way to be a little productive so that you can quickly focus on required logs? There is. By simply color styling your logs based on the log's severity level. This way, you don't miss on that error log or important debug log amongst the continuously rolling logs since your app is deployed. The good news is, it's a simple configuration change that you'll have to make in your Android Studio Editor like below and you're done. Android Studio Preferences -> Search for 'logcat' in the search bar Define your own color coding for different log severity le

Book Review - Agile Android by Godfrey Nolan

This blog post is a candid review of the book titled, "Agile Android", authored by Godfrey Nolan This book is very concise and is a very high level overview of writing tests for native Android development project. It gives you a taste of the tools that you can use to write tests and aid writing more tests. Who does this help? If you're a novice developer wondering what tools to use and how to get started using those, then this book is for you. You could perhaps be that curious Manager who is wanting to wrap his/her head on the tools that your Android development teams use.

Book Review - The One Minute Negotiator

This is a good book that gives real, practical and genuine advice on negotiating - starting from the very definition of what a negotiation is. While the content it less, the author made it enjoyable to read, pause and ponder about his advices as the book progresses.  Read this book, and you might likely want to attend a workshop on this topic by this author. Get your copy from Amazon now.