19169
paged,page-template,page-template-blog-large-image,page-template-blog-large-image-php,page,page-id-19169,paged-2,page-paged-2,stockholm-core-2.4.4,select-child-theme-ver-1.1.3,select-theme-ver-9.12,ajax_fade,page_not_loaded,,qode_menu_,wpb-js-composer js-comp-ver-7.9,vc_responsive
Title Image

Blog

yeah about those hf8r1b
August 18, 2023 In Code, Process, Productivity

Status Reports: How Many Do We Need?

Software Developer Productivity Killer #5: The Dreaded Status Reports

Hello again, digital navigators! We’ve tangoed with ‘useless meetings‘, battled the open-plan zombies, and sailed the treacherous seas of ‘technical debt‘. But hold onto your keyboards, because now we’re diving into the realm of… (drumroll, please)… status reports. And not just one or two. Oh no, it seems everyone and their digital assistant wants one!

📝 The Story of Bob, The Status Reporter

Bob, our fictional yet oh-so-relatable developer, has had a week. He’s juggled tickets, diligently added comments, rolled out code changes, and executed pull requests with the grace of a ballet dancer. Each task gets its neat little description, every commit explains the changes, and pull requests detail the grand picture while referencing back to the ticket. But wait! There’s more!

Enter the Pointy-Haired Boss: “Bob, could you whip up a summary of this week’s progress? And oh, remember those TPS reports?” (If you’ve seen Office Space, you know the pain. If you haven’t, go watch it; it’s a workplace rite of passage). But here’s the rub: isn’t a ticket a status report? Isn’t a commit a status report? Isn’t a pull request… oh, you get the idea.

∞ The Infinite Loop of Status Reports

  1. The Redundancy Factor: Status reports, on their own, aren’t evil. But when they’re layered atop daily standups, PR descriptions, ticket annotations, and commit comments…it starts to feel like someone’s playing a cruel joke. “Bob, we’re gonna need another status report on your status reports.”
  2. Managerial Middlemen: Is the manager’s role merely to be a carrier pigeon, ferrying status notes between developers and higher-ups? It seems even carrier pigeons have more freedom.
  3. Time = Code: Every moment a developer spends summarizing their summaries is time they aren’t coding, innovating, or resolving bugs. The business cost of this is more significant than it appears.

👀 Status Quo No More

  1. The Value of Transparency: The beauty of tickets, commits, and PRs is their transparency. One can easily delve into the history, the changes, and the progress. It’s all there, like a digital journal of a developer’s journey.
  2. Empower Managers with Tools: Instead of burdening devs with ‘one-more-report’, why not equip managers with tools to derive insights directly from existing data?
  3. Automate with AI: Here’s a wild thought: What if we could have intelligent systems that aggregate all these updates and present them in a digestible format? Oh, wait! At Facet Digital, we’re doing precisely that! Take that, TPS reports!

💡 Conclusion

In an era of digital transformation, redundancy is the last thing we need. Bob should be crafting digital masterpieces, not drowning in paperwork. And managers? They should be guiding, assisting, and inspiring, not merely playing data tag.

If you want to ensure your devs are more Bob-like (pre-pointy-haired boss phase), consider integrating intelligent tools. Call Facet Digital to get your development processed dialed in early. Because the best status report is one that writes itself!

✋ Haven’t met Bob in his previous adventures? Well, he’s been battling ‘useless meetings’, dodging the ‘open-plan distractions’, and chipping away at ‘technical debt’. And of course, who could forget his escapade with the zombie code? Stay tuned, because Bob’s journey through the wilds of software development isn’t over yet.

zombiecode
August 17, 2023 In Code, Productivity, Tech Debt

Dead Code: The Zombie in Your Codebase

Software Developer Productivity Killer #4: Dead Code

Greetings, dear readers! Just when you thought the digital waters were safe after navigating through ‘useless meetings‘, ‘open-plan offices‘, and the vast ocean of ‘technical debt‘, here comes another phantom to haunt your code: Dead Code.

Dead code is akin to a zombie in a movie. It’s there, but not truly alive. It doesn’t contribute, yet it can cause a myriad of problems if left unattended. And just like you wouldn’t want a horde of zombies in your backyard, you wouldn’t want dead code cluttering your codebase.

🧟‍♂️ The Un-Life of Dead Code

  1. The Silent Specter: Dead code silently resides in your software. It’s not executing any tasks, not being called upon, but it’s still THERE. It’s like keeping a broken bicycle in your garage, taking up space, collecting dust, and being an overall eyesore.
  2. The Maintenance Nightmare: As your live code evolves and changes, guess what? You might find yourself unintentionally maintaining and updating your dead code. After all, it’s hard to differentiate a zombie from a living being until it tries to bite you!
  3. The Debugging Disaster: Imagine hunting for a bug and sifting through lines of code, only to realize you’ve been chasing shadows in the dead sections of the code. Frustrating, right?

✝️ Why Should We Perform a Dead Code Exorcism?

  1. Clarity and Efficiency: A clean codebase is a joy to work with. It’s easier to read, understand, and modify. Developers spend less time sifting through the ‘zombie horde’ and more time innovating.
  2. Reduced Risk: Old, dead code can be a breeding ground for vulnerabilities. If you’re not actively using or maintaining it, you might overlook potential security risks.
  3. Better Resource Management: Time spent maintaining dead code is time stolen from adding new features or addressing other vital areas of your software.

🔥 Vanquishing The Zombie Horde

  1. Regular Codebase Audits: Make it a habit to regularly review your codebase. Tools and software, properly integrated into your engineering systems, can help identify unused code sections, making the hunt easier.
  2. Embrace the ‘Delete’ Key: If a piece of code no longer serves a purpose and has no foreseeable use, bid it adieu. It’s liberating. Don’t block comment it out just in case. You have source control for that, right?
  3. Documentation is Key: Ensure that your code is well-documented. When another developer jumps in, they should be able to differentiate the living from the undead.
  4. Foster a Clean Code Culture: Cultivate an environment where clean coding practices are championed. A stitch in time saves nine, and a deleted line of dead code can save hours!

💡 In Conclusion

Dead code might seem harmless, but it can drag down productivity and bloat your software project. Be vigilant, be proactive, and remember: the only good zombie code is the one that’s been vanquished!

And if you find yourself amidst a codebase zombie apocalypse, don’t hesitate to call in the experts (oh yes, that’s us). Why wrestle with the undead when a skilled zombie hunter is just a click away? 🧟‍♂️ 🏹 💀

✋ Need to catch up on the other apparitions threatening developer productivity? Check out our previous explorations into ‘useless meetings’, the ‘open-plan office’, and the lurking ‘technical debt’. Stay tuned as we continue our crusade against the forces of coding inefficiency.

iceberg
August 16, 2023 In Code, Process, Productivity, Tech Debt

Technical Debt: When Ignorance Isn’t Bliss

Software Developer Productivity Killer #3: Tech Debt

Ahoy, dear reader! We’ve spoken about ‘useless meetings‘ and the perils of the ‘open-plan office‘. Today, we embark on a voyage beneath the surface to unveil a silent killer, lurking in the deep, dark abyss of codebases everywhere – Technical Debt.

For the uninitiated, technical debt might sound like the overdraft fees on a credit card statement, but trust us, the costs can be even more perilous if not managed. But fret not! We’re here to unveil the mysteries of this productivity assassin and guide you to safer shores.

🌊 Understanding The Iceberg That’s Technical Debt

  1. The Tip of the Iceberg: On the surface, everything seems fine. Your software is running. New features get deployed. But underneath lies layers of rushed code, shortcuts, and bandaids that, much like the bulk of an iceberg, remain invisible to the untrained eye.
  2. The Silent Accumulator: Technical debt accrues silently. It’s the byproduct of fast decisions, expedited features, and temporary fixes. While a quick workaround might speed things up today, it will slow everything down tomorrow.
  3. Feature Slowdown: Ever wondered why the latest ‘simple feature’ took thrice as long as you hoped? Beneath the water, your dev team might be battling tentacles of ancient code and patchwork solutions. The deeper they swim, the harder it gets.

📉 The Business Cost of Ignoring Technical Debt

  1. Lost Time and Money: The longer technical debt remains, the more expensive (in both time and resources) it becomes to address. Your devs aren’t magicians; they’re navigators trying to avoid crashing into that looming iceberg. Code reviews take longer, more bugs appear and are harder to fix the right way, and overall code quality suffers.
  2. Reduced Morale: A team constantly battling the deep-sea monsters of messy code can quickly lose enthusiasm. And a demotivated team isn’t a productive one.
  3. Innovation Stagnation: With so much energy going into managing existing chaos, there’s little left for innovation and growth. Do you really want to be stuck sailing in circles?

🚢 Navigating Away from The Iceberg

  1. Post-Mortem’s Critical Role: Taking shortcuts during an emergency or to expedite a release can be an acceptable strategy. But it’s like borrowing against tomorrow – you must repay it, preferably sooner rather than later. After such incidents or rapid releases, conduct a post-mortem. Assess and catalog the quick fixes and patches applied. This isn’t about finger-pointing but about understanding the new debt that’s been taken on. Prioritize paying down the heaviest debt even before diving back into your feature roadmap. The short-term gain is only beneficial if you’re strategic about the long-term repercussions.
  2. Track Technical Debt: Just as businesses track financial obligations, technical debt should be recorded and monitored. Consider tools or platforms designed for this. If you can’t measure it, you can’t manage it.
  3. Allocate Regular Paydown Time: Embrace that a portion of your dev team’s time needs to be dedicated to addressing and reducing technical debt. Think of it as regular maintenance on a ship to ensure smooth sailing.
  4. Educate and Involve Everyone: Tech debt isn’t just a ‘dev issue’. Business stakeholders should be educated on its implications. When everyone’s on board (pun intended), it’s easier to navigate treacherous waters.

💡 In Conclusion

Technical debt, if left unchecked, becomes that giant iceberg threatening to sink your ship. But with intentionality, regular check-ins, and an understanding that it’s as real as any financial debt, you can sail through smoother waters. After all, in business, as in sailing, forewarned is forearmed.

And if you’re already feeling a bit seasick from tech debt, consider chatting with an expert (hint: us) to help navigate. Why DIY when you have a seasoned captain just a call away?

✋ Keen on avoiding more developer productivity pitfalls? Dive into our discussions on ‘useless meetings’ and the ‘open-plan office’. Stay tuned; we have more voyages planned in this series to guide you through the turbulent seas of productivity.

caveman coder
August 15, 2023 In Code, Productivity

Why Your Dev Wants To Live In a Cave

Software Developer Productivity Killer #2: Open Plan Offices

Ah, the modern open-plan office: a utopia of collaboration, communication, and… countless distractions? If you found yourself nodding (or even chuckling) at our series’ opener on the ever-ubiquitous ‘useless meetings’, strap in! We’re about to tackle another biggie on the list. Say hello to productivity killer #2: Open Plan Offices.

But before we set off on this whimsical journey, if you missed the maiden voyage into the land of ‘why-so-many-meetings’, you can catch up right here. But for now, back to Bob and his dream of becoming a modern-day caveman.

👹 Why Open-Plan is the Freddy Krueger of Productivity Dreams

  1. The Illusion of Togetherness: Open plans were designed to foster collaboration. Yet, they often become a cacophony of ringtones, chatter, chewing sounds, and the unmistakable sound of Bob’s bad ass mechanical keyboard fury. Yes, you’re together, but is any real work happening?
  2. Focus? What Focus? Bob was in The Zone. Remember that? But wait, Jane just remembered a hilarious cat video she simply MUST share with everyone. And there it goes – Bob’s concentration, like a fragile soap bubble, bursts.
  3. The Inadvertent Eavesdropper: Developers, often in their quest for a bug, mutter incantations. In an open plan, Bob isn’t just coding. He’s also inadvertently tuned into three different project updates, a recipe exchange, and someone’s weekend plans.
  4. The Quick Question Conundrum: It’s tempting, oh-so-tempting, to swivel your chair and ask Bob a quick question. Yes, you might get your answer in 30 seconds, saving you a 15-minute search. But here’s the rub: you’ve just dragged Bob out of his flow state. While you saved 15 minutes, it’s costing him 15-30 minutes to get back into the groove. Do the math, and the net productivity just took a nosedive.

🤫 Defeating The Open-Plan Demon

  1. Introduce Quiet Zones: Dedicate spaces where silence is golden. Think of it as a library: a sanctuary where devs like Bob can code in peace, without fearing the next viral video ambush. This should be the developers’ main working area, not some prison cell down the hall without all of their monitors and such.
  2. Partition Magic: No, not a throwback to 90s software – actual physical partitions. Use bookshelves, plants, or even trendy modular walls. Anything that gives Bob his own mini-cave.
  3. Headphones: The Universal ‘Do Not Disturb’ Sign: Encourage a culture where wearing headphones signifies, “I’m deep diving, disturb at your own peril.” And respect it.
  4. Flexible Working Arrangements: Some people thrive in open plans; some, like Bob, contemplate desert islands. Allow for remote working days or flexible hours to cater to all productivity rhythms. Let’s be honest: after the pandemic, this is likely the new norm anyway. (And for exactly these reasons.)
  5. Private Offices and Real Cubicles: The Shields of Solitude: Let’s face it, those half-height cubicles aren’t fooling anyone. They’re like wearing a hat and thinking you’re invisible. Real, full-height cubicles or private offices offer more than just “don’t look at me” privacy. They safeguard devs from the myriad of visual distractions – be it the tantalizing glint of a passing donut or colleagues unleashing their inner mime artists. Visual serenity can be just as crucial as silence for deep focus.

🎁 Wrapping It Up

Open-plan offices aren’t inherently evil. Like a mischievous pixie, they can be tamed with a bit of thoughtful strategy. Respect individual work rhythms, and always be on the lookout for signs of a distressed Bob.

✋ Missed the first productivity killer? The siren song of ‘useless meetings’ awaits you here. And stay tuned because productivity killer #3 is lurking just around the corner.

2023 08 11 16 49 57
August 14, 2023 In Code, Process, Productivity

Why Your Dev Just Bought a Magic 8-Ball

✋This is the first post in a series on software developer productivity DOs and DON’Ts. Check back often for upcoming posts…

Software Developer Productivity Killer #1: Useless Meetings

Picture this: your software developer, let’s call him Bob, is at the peak of his creative genius. He’s coding at the speed of light, the characters dancing on his screen in a coordinated ballet. Just then, the dreaded ping – yet another meeting request. Bob’s heart sinks, his momentum wanes, and he wonders if he should swap his laptop for a typewriter to dodge digital meeting invites.

Alright, now before you brandish pitchforks my way, let me clarify – not all meetings are evil. Some can be life-affirming soul-searching odysseys. But many, oh-so-many, are like that extra sprig of parsley on your dish. Looks nice, but no one knows why it’s there.

😱 Why Developers Loathe The Meeting Monster

  1. The Zone Disturbance: Every time a developer is yanked out of “The Zone”, it takes a good 15-30 minutes to get back into it. The Zone is that magical realm where developers wield their wizardry. You know what doesn’t exist in The Zone? Meetings about whether to use Oxford commas in comments.
  2. The Mismatch of Tongues: Developers speak in code; managers often in spreadsheets. It’s like expecting a cat and a goldfish to discuss the merits of wet vs. dry food. Spoiler: the goldfish doesn’t care as long as it’s wet.
  3. The “This Could Have Been An Email” Syndrome: 85% of what’s discussed in meetings (okay, maybe a cheeky estimate) could have been summed up in a well-crafted email. And the other 15%? Probably could have been a Slack message.

⚔️ How To Slay The Useless Meeting Dragon

  1. Agenda is a Must: If you can’t write down what the meeting is about, chances are it doesn’t need to happen. An agenda makes the difference between a focused huddle and an aimless gossip fest. Some even go farther – consider adopting the ‘Amazon 6-Pager’ method where dense topics are distilled into a concise 6-page narrative; it encourages clarity and deep thinking…and provides a higher bar to requiring a meeting.
  2. Time is Money; Cap It: Unless you’re solving the mysteries of the universe, most meetings shouldn’t exceed 30 minutes. Set a timer if you must! And if anyone starts with, “This might be off-topic, but…” – it’s a trap!
  3. Ask “Who Really Needs to be Here?” If Bob’s expertise is in back-end development, he probably doesn’t need to opine on logo colors. Send Bob back to his magical coding realm. He’ll thank you. So would your CFO if he could calculate the ROI of the salaries in the room vs the outcomes of the meeting.
  4. Post-Meeting Homework: Summarize. Distribute. Action. If there are no clear next steps after a meeting, then what was it all for?

💡 Conclusion

Meetings aren’t the enemy. It’s aimless, purposeless, could’ve-been-an-email meetings that developers detest. Think before you ping. Remember, every time you pull a developer into a needless meeting, somewhere in the world, a Magic 8-Ball gets a question like, “Should I attend this meeting?” And the answer is, more often than not, “Outlook not so good.”

Next time you’re tempted to drag your tech team into a meeting, ask yourself: “Do I really want to be the parsley on Bob’s plate?” If the answer is no, rethink that invite.

Now, if you’re struggling to optimize team productivity and communication, remember there are experts (like yours truly) who can help. Because, let’s face it – you could do it, but why would you when there’s a cheeky genius available for hire? 😉

Facet UX Design Process
January 18, 2016 In Design, Process

The Facet UX Design Process

Whether you have a fledgling idea or an existing product already in the market, our UX design process helps to clearly define your product experience and sets your developers up for success. Here we use a six-step design process in effort to develop a great product that clearly solves a problem in a validated market. This process, which we call a “Phase 1 Design Sprint” is used as a design guideline, but can be modified based on the existing research and stage of your product.

READ MORE

Supra Colorizer Featured Image
July 22, 2015 In Releases

Supra Boats Colorizer Case Study

Supra Boats, manufacturer of high-performance, luxury water sports boats, partnered with Facet Digital to redesign and develop their boat colorizer application that allows customers to customize and purchase their perfect Supra masterpiece. This colorizer would need to optimized to look great on both the supraboats.com website and the digital catalog app for iOS and Android tablets being designed and developed in parallel by Facet Digital.

READ MORE