Beginning with a story here. Back in 2008, I was a couple of years out of college and working for a software company in Dhaka, Bangladesh. Like many of my classmates from my college, I was studying GRE alongside my job for a PhD admission in a reputable US university. That process being long and uncertain, I also applied for an MBA program at the University of Dhaka as a backup plan. The GRE preparation came in very handy and I qualified for the evening MBA program. I started MBA classes in January 2009 before the universities in USA and Canada made their decision on my application. There, I took a course on Management. I was too naive and still too much an engineer to pay attention.

But this image that our professor drew on the board got stuck in my head to this day.

Fast forward a decade later and I still like how cleanly it captures the essence of performance of an employee as a combination of the employee’s ability, level of motivation, and an enabling environment.

Given this is how high-performers are, it’s possible to plot a similar graph for low performers as a diagnostic report. If such a diagnosis is right, it can provide a valuable strategy for managers and employees to work towards improving employee performance. For example, if an employee lacks skill and motivation but fits very well within the work environment, a manager can focus on skills training and suggest therapies or employ various techniques to increase motivation. Similarly, if an employee is unable to acquire the skills for a particular job, focusing on motivation or changing the environment for that employee may not fix the low performance issue.

In the past 14 years of my time as a professional, I’ve seen several symptoms of low performance. Here I present a list of such symptoms for you to think about and may be use as an exercise to diagnose the performance problems in terms of ability, motivation, and environment related factors. For each of these symptoms, you can try to visualize the chart and come up with interventions that can help improving employee performance.

1. New hire is too slow to ramp up: You were impressed by a candidate during the interview. The same interview process was used to find many high performers in the past. But this employee is struggling to ramp up.

2. Knowledge vs. application: You have an employee who’s always studying job related literature and shows a great deal of interest in training, but can’t translate the knowledge into application.

3. Complains about the lack of time: You have an employee struggling to produce the best outcome. In your one:one meeting, the employee always complains about lack of time even after you give him/her the time.

4. Frequently runs into conflicts: Your most skilled employee is causing too many conflicts within the team.

5. Can’t write thoughts down: You have an employee who’s been unhappy about things and spreading general negativity in the team. When you want them to write it down, they are unable to produce a precise writeup about the problems and potential solutions.

6. Doesn’t make hard decisions timely: You have a leader that stays away from making hard decisions. In their mind, they want someone else to force them take the hard decision.

7. Isn’t aware of better ways to solve old problems: You have an employee who’s expert in certain ways of delivering work but lacks awareness of newer and more efficient ways.

8. Doesn’t take initiative: You encourage and reward employees to take initiatives that help the business. Yet, you see an employee is not taking any noteworthy initiatives.

For performance problems like these, the good news is, once you can diagnose the problem as factors of skill, motivation, and environment, you can deploy the right intervention to turn things around. I found this simple diagnosis method to be helpful in my career, and may be that’s why the image got stuck in my head for so long.

I hope this helps you, too.

This week I took a couple of days to focus on my mid-thirties. It got me thinking about what I actually love doing as a hobby. The list is fairly small, walks with the family, soccer, tennis, coffee with friends, reading, writing, car videos, and Netflix.

Thinking about how I spend my idle time, I realized that I missed two things that I actually love and spend a fair amount of time on: stock markets and reading open-source code.

Ruby on Rails got me into the habit of reading code. Back in the day before bundler, the whole Ruby on Rails framework was in the plugins directory of our code. It had little documentation. A lot of methods accepted options as arguments, and looking at the source code was often the only way to find what options were available. However, that necessity soon turned into a hobby for me, and I keep reading source code of open-source projects just for fun. GitHub mobile UI helps a lot.

To name a few, I read some part of the source code of Ruby on Rails, Ruby, RSpec, BackboneJS, ASP.NET MVC, Golang, UnderscoreJS, VueJS, ReactJS, Terraform, Chef, Jenkins, Lucene, ElasticSearch, Docker, and many other popular tools and libraries.

During this mid-thirty reflection, I decided to start a YouTube channel called ReadCodeWithSohan where I’ll be screencasting as I read some part of an open-source project. Today, I posted my first video on reading the JQuery source code, which I didn’t really read until now. I hope you enjoy it.

Since I commonly work with a diverse group of people, this post is a way for me to broadcast some quick tricks that may help our working relationship. When we work together, let’s do this:

Trust is only earned when it’s mutual. Let’s work with this shared belief.

Context is everything. Most importantly, show me why we need to work on something. If the answer isn’t clear in your mind, we can work together to build a crisp context.

Solutions for problems you’re raising. Ideally, you’ve already thought about a few solutions with some measure of feasibility for each, and you come with an open mind. I know you care about the problem only if you spent some time thinking about a few solutions.

Clarity between your evidence and assumptions. Assumptions are often essential to move ahead, but treating assumptions as evidence can be harmful.

Output is the focus, our egos aren’t. That said, let’s be mutually respectful.

Time is managed. Let’s manage our expectations given the time we have. Blaming the shortage of time shows a lack of skill.

Writing is a great thought exercise and good write-up scales infinitely. Let’s write and rewrite our thoughts, specially when we’re unclear about those.

Standup comedies, biography, soccer, politics, investment, tech, leadership, Netflix, movies, and similar topics are cool. Sorry, not much of a Hockey or Basket Ball fan. Mostly a passive music listener and happy to listen whatever is on radio or a YouTube playlist.

If you have a similar list, I’d be happy to read and respect it. Please send along.

Source: Audrey on Flickr

I think nobody knows how to stitch together an app with full-stack micro-services. I have the following open-questions if you disagree. Of course, if we could send people to moon, we could solve these problems. But the question is, is it worth and should your team solve these problems? Especially, for small teams?

1. How to render the UI from tens of independent micro-services into the same web page?
2. How to ensure the JS and CSS libraries are compatible within all of the independent services?
3. How to aggregate logs from the services to be able to trace a user / request / transaction?
4. How to measure and reduce overall latency and spinner-fatigue?
5. Which off-the-shelf framework can be used for achieving the above?

Headless micro-services are easy to build, but in many ways are similar to integration over database. It helps scaling teams, but even if you have many teams, I’d say extract service where it makes sense instead of adopting that model as the default choice.

I suggest being careful about following conference talks and blogs on how cool micro-services are. It may work for big and gig tech. They don’t always turn a profit! Your small teams are more likely to drown in worthless complexity from a micro-service architecture.

Gone are the days when I used to go to a ton of local developer meetups. After Polyglot YYC, this was the second conference I joined this year. This was a 50/50 event for me in terms of like vs. dislike. Here goes my notes:

Ix-Chel Ruiz presented the keynote to start the day. Her storytelling style reminded me of WWII movies, where a lot of cloudy and gloomy scene keep getting darker and darker, ending with a deep sense of sadness. Ix-Chel used quotes from the likes of Prof. Galloway and Elon Musk to tell a story about how the modern tech is creeping into our private lives. I wish she had prepared for the keynote a little better. She paced it so slowly yet ran out of the material half-way through the slot. In a way I liked the early finish because I just wanted to feel optimistic about the future.

The stunning view of Banff landscape brightened up the mood a bit:

There were 4 other talks on the same day and I liked the talk on Vue.js and Vuetify by Dave Paquette. Since, I use VueJS at work, it was easier to relate to. Dave showed us how he’s using Vue.js to render a real-time collaborative UI for complex seating requirements at FlyOver Canada.

Among other talks, there was one on data management for machine learning and another one on Kotlin, I liked these talks but didn’t fully relate with the topics.

There was a talk on using Kafka for geo-fencing applications. The presenter could’ve spent more time on the parts of kafka that makes it a compelling case for using in geo-fencing applications. Instead, he delved into the code, java, and jar files.

There was another talk on using EventStore for event sourcing. The presenters set the story saying that they had an opportunity to try new technologies while rewriting a “monolithic” application and they used EventStore with “multi-services” to implement it so it’s easier to evolve the system. I’d love to see some evidence of the desired outcome, that’d be motivating. But in the end it was about the “how” instead of the “why”.

One thing to note is, even for talks that could be more engaging, I still learned quite a few new things.

Beyond the talks, I like going to conferences as it opens the opportunity to meet new people and some known faces. In hindsight, had I known about this event before the talks were finalized, we’d have submitted a few proposals from Cisco. Looking forward to the next round for an opportunity to share some innovative work we’re doing at Cisco.

Looking at our git logs from Cisco AMP for Endpoints Console, I see that we introduced feature flags back in January, 2014. The reason I got interested in it is because even after all these years of use, today I had to build a new concept on our feature flag code. If you’re already using feature flags or thinking about adding feature flags to your project, this experience report may be helpful.

Photo credits to Michael Newton

Back in 2014, we were growing as a team, but wanted to keep working on a single shared code. We perceived that the productivity gain of multiple teams working on a shared code would outweigh cross-team dependency issues. As we started working on multiple features in parallel, mostly independent with different release dates, we saw unfinished work on one feature was blocking the release of a completed one. After some research, we decided to introduce feature flags in our code.

First, we read Martin Fowler’s article on this topic as a guideline. Today, we have 195 feature flags in production. Over time, we have extended the use of feature flags with new concepts and I wanted to document it here for everyone. Fowler’s blog also published a more detailed and updated post later. The taxomony used here is different from Fowler’s because I find the following to be more relevant for our product.

1. Database stored: We store the feature flags in the main database so that the features can be toggled without needing a code deployment.
2. Cached: Feature flag lookups are cached for performance.
3. Temporary vs. permanent: We mark some feature flags as temporary when the primary goal is to incrementally release code to production. Temporary feature flags are regularly cleaned once the feature is complete. 13/195 currently used feature flags are marked temporary.
4. Self-serve: We tag some feature flags as self-serve where users need to opt-in to use the feature.
5. Limited availability: For self-serve feature flags, we tag some features as limited availability. It allows us to release self-serve features to selected customers.
6. Globally enabled: We have a mechanism to globally enable or disable a feature flag. 131/195 feature flags are currently marked globally enabled. This number varies by deployed environments.
7. Enabled for all, but: We have a mechanism for enabling a feature flag for all but some specific targets.
8. Multi-target: Sometimes we attach a single feature flag to multiple domain objects such as tenant, user, subscription tier, etc.
9. Hierarchical: We use a fallback mechanism for feature check. For example, the check if a user have file upload permission, we check it for the specific user, then fall back to the tenant it belongs to, and finally fall back to the feature itself being globally enabled.
10. Code generator: We use a single-command code generator to introduce a new feature flag to our code. It takes care of the database migration, seed entry, and code references.
11. Circuit-breaker: For integration with external services, we’ve used feature flags as a circuit-breaker to gracefully handle third-party downtime.
12. Environment-flags. We deploy the product to multiple geographic environments, including a private cloud model. Certain features behave differently based on the deployment. Using feature flags make it easy to develop and test such differences before deploying to each target environment.

There are reusable libraries and services such as LaunchDarkly that provide rich APIs and user interfaces for feature flags. At this point, even with all the aforementioned concepts, our custom implementation of feature flag is quite straight-forward and easy to evolve. It has been a key ingredient for our frequent iterative deployments with 6 teams working on diverse features in parallel on the same product.

In my last post, I claimed software architecture is all talk and no show. When we have a visible one, it’s a bunch of poorly drawn boxes and lines. I don’t have a problem with boxes or lines, but I do like beautiful drawings.

Despite many standards, we still mostly use whiteboard drawing of boxes and lines for sharing software design as we build new systems or introduce new team members. Where it sucks is the lack of evolution and context of the rest of the system that’s not drawn on the board.

A digital repro of software architecture diagrams often happen in PowerPoint or similar tools that allow us to draw boxes and lines. This process is so rough that people just give up.

At work, I have been using WebSequenceDiagram. While it’s still not an eye-candy, I like the fact that you can draw a diagram from using plain text. Consider this as an input to create the accompanying diagram:

1
2
3
4
5

title Toilet Flush System
User -> Flush Lever: Push
Flush Lever -> Outlet Valve: Open
Outlet Valve -> Toilet Bowl: Water
Outlet Valve -> Inlet Valve: Open

While this text to sequence diagram is a great achievement for a tool, I don’t see such tools for software architecture diagrams. Here’s my wishlist of features that I’d want in a software architecture tool:

1. Text input. Allows us to easily create the diagrams and use all the version control features.
2. Map like UX: Allows us to easily transition between higher and lower level components.
3. Beautiful.

Do you know any? Do these requirements make sense?

We have a problem with software architecture. Let’s face it. Find the architecture diagrams of the products you’re working on and answer these questions:

1. Did you find it?
2. Does everyone in your team know where to find it?
3. Is it up-to-date?
4. Can you see how this system scales, handles failover, monitors performance, or how it’s secured?
5. Can you see how it evolved over time?
6. Can you train a new team-member using this diagram?

This is the first micro-post of a series of such as I aim to build a compelling case for fundamentally changing software architecture diagrams.

Image source: Kalvis

“I am a mango”.

First, mangoes are in-season, and I still remember the juicy sweetness of the mango I had just the night before. So, when the coach asked each of us to be a fruit, I didn’t think twice. One of my coworkers was a kiwi, another one apple, and so on. The idea was to group us by color, then by size. This got us, twenty people in the class, moving and engaged. It was part of a two-day design thinking course. The coaches used the fruit game to bring some energy into the room as well as to pave the way for the next exercise - grouping a bunch of ideas by cost and the level of innovation.

I find that professional trainers bring play at work, especially for sessions that span hours or days. However, on a typical day to day business, I don’t see much play activity at work. Hoping to bring in some play activities to my work going forward. Here are some ideas for play activities based on what I saw so far:

Paper planes: Having small groups build paper planes and the winner has the most number of planes crossing a line.

Catch and throw: A ball or a ball-like object changing hands and the person catching must find someone that didn’t catch it already.

Portrait: Everyone draws a portrait of another person looking at their face without looking at the paper.

Quiz: An online quiz that maintains a leaderboard throughout a session.

Exercise: Getting everyone out of their seats to do a quick one-minute exercise.

Design Thinking course, Cisco Calgary Office, AB, 2019

One benefit of working at Cisco is access to the many learning and development resources. Our learning and development org arranges hundreds of courses throughout the year. Moreover, we have a reimbursement program for external courses, conferences, books, and subscriptions to online learning programs and publications.

In the past 6 years, I have immensely benefitted from these resources. Here’s a list of the learning resources I’ve used.

1. Safari books online, aka O’Reilly learning: In the past 3 years, have taken 3 online trainings and 7 books on this platform so far.
2. Design thinking, 2019: A two-day course taught by consultants about how to apply the principles of design thinking to communicate and derive solutions to complex problems.
3. Mindfulness, 2019: A 5-week program taught by consultants, with one hour per week, where I learned about staying mindful and effective at work amid all the chaos that surrounds it.
4. Tufte one-day course, 2019: Attended a course taught by Edward Tufte on data visualization and learned about the principles that make compelling data visualization.
5. SANS incident response, 2018: A packed week-long program where I learned to think like a hacker by learning about and then hacking some interesting vulnerabilities in systems.
6. Cisco R00tcamp, 2017: A packed week-long program where I learned hands-on pen-testing techniques to build more secure software.
7. Cisco threat-hunting, 2017: A daylong course to find root case that triggered a security threat using integrated Cisco tools, including the product I build with our team.
8. RailsConf, 2015: It was a big opportunity to meet the community and bring some of their practices in-house. For example, we started using BugSnag after learning about it in the conference.