Develpreneur: Become a Better Developer and Entrepreneur Rob Broadhead

Welcome back to Season 21 of the "Building Better Developers" podcast! In this episode, "Boost Your Developer Efficiency: Automation Tips for Developers," we explore strategies to enhance productivity. As developers, we often focus on optimizing processes for clients but neglect to apply the same principles to our own work. This episode aims to change that by identifying repetitive tasks in our daily routines and exploring ways to automate and streamline them. Join us as we share insights and practical tips to help you become a more efficient and effective developer.


Listen to the podcast and Boost Your Developer Efficiency





Identifying Opportunities for Developer Efficiency

The first step in enhancing productivity is taking inventory of daily repetitive tasks. Whether it's managing emails or routine development activities, there's always room for improvement. For instance, using email filters, labels, and rules can significantly reduce the time spent sorting through emails. If you don't use these tools, start today by setting up a few simple rules that will organize your inbox and save you time in the long run.


Automating Development Tasks for Greater Efficiency

Many routine development tasks can be automated to save time and reduce errors. Consider common activities like status reporting, version control, branch creation, and code merging. Automating these tasks can streamline your workflow and free up time for more critical activities.


Version Control and Branch Management: If you create multiple branches daily, consider scripting the branch creation process. This can include automating the naming conventions and ensuring consistency across your projects.


Build and Deployment Automation: Setting up Continuous Integration/Continuous Deployment (CI/CD) pipelines can automate the build and deployment process. If a full CI/CD setup isn't feasible, simple scripts can still automate tasks like compiling code, copying files to servers, and packaging applications.


Database Management: For projects involving databases, having a set of SQL scripts to create users, tables, and other necessary elements can save significant time. Automating these foundational tasks ensures consistency and reduces the potential for errors.


Enhancing Developer Efficiency with Shell Scripts and Scripting Languages

Shell scripts and other scripting tools are invaluable for automating repetitive tasks. Whether you're using shell scripts on a Unix system or PowerShell on Windows, these tools can significantly enhance productivity.


File Operations: Automating file movements, backups, and log management can save time and ensure accuracy. For example, you can write a script to handle directory crawling, file copying, and log parsing, which you might frequently perform.


Environment Setup: Setting up development environments can be tedious, especially when dealing with multiple projects or clients. Interactive shell scripts can automate the installation and configuration of required software, making it easier to start new projects.


Boosting Efficiency with Macros and IDE Features

Most Integrated Development Environments (IDEs) offer features like macros and code snippets that can automate repetitive coding tasks. By setting up templates and custom shortcuts, you can reduce the time spent writing boilerplate code.


Code Snippets: Define code snippets for commonly used blocks of code. This not only speeds up coding but also ensures consistency across your projects.


IDE Plugins: Explore plugins that enhance your IDE's functionality. Tools like SonarLint can help you write cleaner code by highlighting potential issues as you type.


Improving Developer Efficiency with Automated Testing and Quality Assurance

Automated testing is another area where you can save time and ensure code quality. Writing unit tests for your code allows you to quickly verify functionality without manu

This podcast episode delves into the compelling discussion on why building a portable development environment is essential. Imagine a development environment where code knows no boundaries. Michael and Rob explore the art of crafting a coding haven that seamlessly adapts to any device or location. In an era where remote work has become the norm, they underscore the paramount significance of untethered productivity. Prepare to embark on a journey through practical strategies and ingenious solutions that empower developers to thrive, regardless of the ever-changing environments they encounter. Whether coding from a cozy home office or a secluded beachside retreat, this episode promises to equip you with the tools and insights to create a genuinely mobile development sanctuary.


Listen to the Podcast on how to Build a Portable Development Environment





The Value of a Portable Development Environment

The conversation kicks off with a riveting tale that resonates with every developer's worst nightmare – a laptop casualty during the throes of travel. However, this particular developer had the foresight to curate a portable oasis, meticulously crafted with a suite of nomadic applications residing on an external hard drive. This clever contingency plan allowed them to seamlessly plug their digital lifeline into a business center PC, continuing their workflow with minimal disruption. This anecdote serves as a resounding testament to the indispensable value of cultivating a truly mobile development ecosystem that can be rapidly resurrected and thrive on any hardware it encounters.


Tools for a Portable Development Environment

The podcast outlines several tools and strategies to build a portable development environment:


Portable Apps: Originally designed for Windows, portable apps allow developers to carry their essential tools on an external drive and run them without installation. This is especially useful when dealing with limited or restricted environments.

External USB Drives: The hosts recommend using high-speed, large-capacity USB drives to store essential development tools and environments, such as IDEs, development frameworks, databases, and build tools.

Cloud Storage: Services like One Drive, Dropbox, Google Drive, and Box are essential for syncing development environments and files. Regular backups to these services ensure the development environment can be restored quickly if a local machine fails.

Version Control: Regularly committing code to a version control system like Git is crucial. This practice ensures that code changes are continuously saved and can be retrieved from any machine.


Leveraging Virtualization and Containerization

The podcast also explores more advanced solutions like virtualization and containerization:


Virtual Machines (VMs): VMs, such as those provided by VMware and Virtual Box, allow developers to create fully configured environments that can be easily cloned and deployed across different machines. This method has been around for a while and offers a robust way to manage development environments.

Containers: Technologies like Docker and Kubernetes offer a modern approach to virtualization. Containers allow developers to package their applications and environments into lightweight, portable units. These can be run on any machine with a container runtime, providing consistency across different development setups.

Cloud-based IDEs: Tools like Cloud9 provide cloud-first development environments that can be accessed from anywhere. These IDEs offer the flexibility of working from various devices without worrying about local setup issues.


Practical Tips for Developers

The hosts provide several practical tips for maintaining a portable development environment:


Consistent Backups: Regularly back up development environments to both local and cloud storage. This ensures that all tools, configurations, and code

Welcome to another captivating episode of "Building Better Developers." Join your hosts, Rob Broadhead and Michael Meloche, as they delve into the intricate world of software development and share their hard-earned wisdom from the frontlines. Today's topic is a familiar challenge that developers often face: the delicate balance between adhering strictly to software development requirements and unleashing one's creative prowess.






Navigating Software Development Requirements

In our ever-evolving journey as developers, we frequently encounter projects where our innate creativity and problem-solving abilities must temporarily yield to the rigors of predetermined requirements. While this constraint may not be the most conducive environment for fostering unbridled innovation, it is sometimes unavoidable – particularly in fixed-bid projects or highly regulated domains such as government contracts, where adherence to stringent guidelines is paramount.


The Challenge of Strict Software Development Requirements

One of the most frustrating experiences in software development involves projects where clients demand only minimal changes to existing code. Often, the codebase is riddled with inconsistencies that make it a nightmare to read and maintain. Despite knowing the code could be vastly improved, rigid requirements prevent significant modifications.


This scenario is common in environments where developers lack direct access to the end customer. Instead, they work in silos, writing code strictly to the documented software development requirements. This can feel like working with blinders on, unable to see the broader vision or potential improvements.


The Importance of Clarifying Software Development Requirements

Understanding software development requirements thoroughly is crucial. Developers must ask questions and seek clarification to ensure they're on the right track. Misunderstanding or making assumptions about the requirements can lead to wasted time and effort, producing a solution that doesn't meet the client's needs.


One effective approach is to restate the requirements in your own words and seek confirmation. This could be through an email or a quick meeting, ensuring both parties have a clear and shared understanding. Doing this prevents unnecessary rework and aligns your work with the client's expectations.


A Cautionary Tale: The Pop-Up Window Incident

A cautionary tale illustrates the pitfalls of deviating from software development requirements. A young, enthusiastic developer once worked on a project requiring a simple confirmation message. Instead of a straightforward status bar update, he created a flashy pop-up window with blinking text that disappeared after a few seconds.


The client hated it. The blinking text was distracting, and the auto-dismissing message often went unnoticed by users. This deviation from the requirements wasted the developer's time and frustrated the client, who expected a simple and functional solution. The lesson here is clear: stick to the software development requirements unless you have explicit approval to innovate.


Understanding Scope and Effort in Software Development

Another critical aspect is understanding the scope and effort required for a task. If a task is expected to take a short amount of time, spending excessive hours adding unnecessary features is inefficient and costly. Always communicate with your client or project manager if you encounter unexpected challenges that might extend the timeframe.


Agile methodologies, such as daily standups, are designed to catch these issues early. If a task is taking longer than anticipated, raise it promptly. This transparency helps manage expectations and allows for re-prioritization if necessary.


Team Dynamics and Collaboration

In team environments, your work often impacts others. Delays or deviations can cascade, affecting the entire project's timeline. Thi

Welcome back to another episode of Building Better Developers. Today, we’re tackling an issue that every developer faces at some point: panic during software delivery. Whether it’s a critical bug or a new feature that isn’t functioning as expected, panic can strike anytime your software fails in the hands of a user. Rob and Michael cover handling software delivery panic with practical tips and real-life examples.


Listen to the Podcast on Handling Software Delivery Panic





The Inevitable Bug: Why Panic Happens

Delivering software is a delicate process. Even when you’ve thoroughly tested your code and believe it to be bulletproof, something can always go wrong. Often, the panic ensues because:


Unexpected User Behavior: Users may interact with the software in ways you didn’t anticipate. This is particularly common in beta tests or early releases where feedback is crucial.

Overlooked Bugs: Some users have a knack for breaking things. These users often find bugs that slipped through your QA processes.

Critical Stakeholders: When a manager, CEO, or client encounters a problem, the stakes feel much higher. Their frustration can quickly escalate to panic.


Real-Life Panic: A Case Study on Handling Software Delivery Panic

Recently, Rob faced this scenario with a technically knowledgeable customer. Despite understanding the development process, the customer encountered a show-stopping bug in an alpha version. Their immediate reaction was that the project was nowhere near completion, creating a sense of panic.


During our call, he expressed concerns that none of the features seemed to work. He acknowledged that bugs and design flaws were expected at this stage, but the issue was so severe that it led to a dramatic loss of confidence in the project.


Handling Software Delivery Panic

Step 1: Stay Calm and Analyze

The first and most crucial step when faced with panic is to stay calm. Take a deep breath and focus on understanding the situation:


Reproduce the Issue: Identify the user's steps to encounter the bug. Sometimes, it’s as simple as a permission issue or an unanticipated input.

Prioritize Fixes: Address the most critical issues first, especially those that block user progress.


Step 2: Effective Communication

Reassure the stakeholders that you’re on top of the situation:


Acknowledge the Problem: Validate their concerns and show you understand the impact.

Outline the Next Steps: Explain how you plan to fix the issue and provide a realistic timeline.


Step 3: Learn and Improve

Use this experience to strengthen your development and testing processes:


Enhance Testing: Incorporate the steps that led to the bug into your testing scenarios. Automated tests can help catch these issues earlier.

Add Logging: Improve logging to gather more information if a similar problem arises in the future.


Real-Life Tips from Experience

Michael shares an insightful story about a shared work experience. Despite rigorous testing, their boss would find bugs within minutes of a release. This constant scrutiny drove home the importance of thorough testing and the psychological pressure of delivering seemingly flawless code.


One key takeaway from Michael’s story is the value of Test-Driven Development (TDD). By writing tests before the actual code, you ensure that each function meets the specified requirements. This approach not only catches potential issues early but also clarifies the expected behavior for each part of your application.


Practical Advice for Developers

Before starting on a new feature or bug fix, consider the following:


Clarify Requirements: Ensure you have detailed requirements, including user input constraints and expected outputs.

Define Acceptance Criteria: Clearly outline what constitutes a successful implementation.

Implement Robust Logging: Log critical operations to s

Welcome back! In our ongoing discussion on improving life and technology, today's focus is on a more dramatic scenario: saving customers from potential disaster due to legacy code. When does legacy code need to be retired, and what signs indicate it's time for a major overhaul? We'll dive into these questions through real-world examples and expert insights.


Listen to Rob and Michael Discuss ways to Deal with Legacy Code





The Legacy Code Conundrum

Legacy code refers to outdated software that still performs necessary functions but is based on old technology. The core question is: when does maintaining legacy code become impractical or even risky?


Our host recounted an experience with a client who had a custom application built on the Eclipse foundation RCP with additional dependencies like Adobe Flash. When the host encountered this system in 2021-22, the last update to the code had been in 2014. The application's underlying technology was so outdated that it was incompatible with modern systems. This scenario is not unique; many organizations rely on aging software that becomes increasingly difficult to maintain as technology evolves.


The Case Study: A Ten-Year-Old Application

In the host's case study, the client's custom application was built on an old version of Java and Eclipse, using technologies like Flash that are no longer supported. The application worked fine until system upgrades rendered it inoperable. Initially running on multiple machines, the application was eventually down to a single operational machine. This machine was critical: if it failed, the entire application would be lost.


Despite having the source code, the modernization process was fraught with challenges. The task involved updating libraries, replacing deprecated technologies, and rewriting significant portions of the code. After six months of effort, it became clear that a complete rewrite was necessary. The core JDBC connections were outdated and incompatible with modern systems, necessitating a significant redevelopment effort.


When to Rewrite: Key Considerations

Technology Obsolescence: If the technology stack is no longer supported, it's a red flag. Modernizing might involve not just updates but a full-scale rewrite.

Compatibility Issues: New system upgrades may not support old applications. As seen in the host's example, upgrading to a newer operating system rendered the application unusable.

Developer Expertise: Often, the original developers are no longer available, and current teams may lack the knowledge to maintain or update the legacy code effectively.

Cost and Risk: Maintaining old code can be costlier and riskier than starting anew. Constant patching can introduce new bugs, and outdated software may pose security risks.


The Modernization Approach

The podcast highlighted the importance of understanding the existing system and planning a phased approach to modernization:


Assessment: Conduct a thorough assessment of the current system, identifying critical components and dependencies. Determine what can be salvaged and what needs replacement.

Data Migration: Plan for data migration from the old system to the new. This may involve extracting data manually or through automated scripts.

Incremental Development: Instead of a big-bang approach, develop the new system in phases. This allows for continuous integration and testing, reducing the risk of total failure.

User Experience: Consider whether the new system needs to replicate the old user experience or if a new, modern interface would be more beneficial.


Real-World Challenges

Michael, the co-host, shared his current project in the healthcare sector involving an old IBM AS/400 system. This green-screen, keyboard-driven application was solid but outdated. Key challenges included integration with unsupported systems and the need for continuous deployment and integration.


Leg

Welcome back to another insightful Develpreneur conversation with Rob and Michael on communication. In this episode, they focus on tools and expectations. Over the years, communication methods have evolved significantly, and with them, the expectations surrounding their use have also changed. Today, we'll explore different types of communication tools, the appropriate contexts for each, and how to manage expectations around them.


Let's listen to what Rob and Michael say about Navigating Communication Tools in Modern Workplaces.





The Evolution of Communication Tools

When many of us started our careers, options were limited to email and newsgroups. Text messaging was unheard of, and instant messaging platforms were still in their infancy. Today, we have many communication tools, each serving different purposes and contexts, both personal and professional.


Instant Personal Communication

Text messaging on personal phones represents the most immediate form of communication. This is akin to someone tapping you on the shoulder, expecting a quick response. In a professional setting, tools like Slack or Microsoft Teams serve a similar purpose. These platforms are more passive compared to text messages but still imply a need for timely responses during work hours.


Dialog-Based Communication

Moving beyond instant communication, we enter the realm of dialog-based tools, such as email. Unlike instant messaging, emails allow for more thought-out responses and generally have a lower expectation for immediate replies. Social media messages, like those on LinkedIn or Facebook, also fall into this category but often carry even less urgency.


Setting Communication Standards

With the variety of tools available, setting clear standards within your organization or personal workflow is crucial. Understanding the urgency and expected response times for different communication methods helps manage both sender and receiver expectations.


Personal and Professional Boundaries

A key point raised was the importance of setting boundaries, particularly when juggling personal life, primary job responsibilities, and side hustles. The type of job you have significantly impacts how you manage communications. For instance, those in mission-critical roles, such as healthcare, need to be more responsive to urgent communications, even outside regular working hours.


Prioritizing Communication Channels

To maintain a balance, prioritize communication channels:


Phone Calls: Reserved for urgent or critical issues requiring immediate attention.

Personal Texts: Quick but less urgent than phone calls.

Professional Messaging Tools (Slack/Teams): Used for work-related communications during business hours.

Email: For detailed, non-urgent communications that allow time for a thoughtful response.

Social Media: Generally for personal use, but can also serve professional networking purposes with a lower expectation for immediate response.


Managing Notifications and Availability

Modern tools offer ways to manage availability and notifications effectively:


Do Not Disturb: Most smartphones have features to limit interruptions during non-working hours.

Status Indicators: Use status indicators on platforms like Slack to communicate availability. However, use them judiciously to avoid them being ignored.

Scheduled Quiet Times: Tools like Apple’s Screen Time and similar features on other devices help enforce boundaries by limiting access to apps during designated times.


Effective Use of Calendars

Utilize calendars to block out time for focused work, meetings, and personal breaks. This transparency helps colleagues understand your availability and plan accordingly. Additionally, communicate your working hours clearly to manage expectations around response times.


Avoiding Digital Overload

It’s crucial to take control of digital tools rather than l