There are several paths to starting a career in software development, including the more non-traditional routes that are now more accessible than ever. Whether you're interested in front-end, back-end, or full-stack development, we offer more than 10,000 resources that can help you grow your current career or *develop* a new one.
Three Reasons Why You Should Attend PlatformCon 2024
Minimum Viable (?) Product [Comic]
In the course of talking about job hunting with friends, colleagues, and randos on Slack and elsewhere, I end up talking about resumes. A lot. There is, (in my (not so) humble) opinion, a sizeable misunderstanding about what resumes are, what they do, how they should look, the effort one should (or shouldn’t) put into creating them, and more. Given the current period of churn in the tech industry and the resulting uptick in the frequency with which I’m having these types of conversations, I decided to commit to what’s become a standard part of my “so you’re looking for a new job?” shpiel to paper (or at least electrons). So… what, in my (again, not so humble) opinion, are resumes meant to do? Contrary to popular belief, common use, and what you may have been told in school at some point, a resume is not a loving, inciteful, and/or detailed retrospective of your work history. It is not meant to stand as de facto proof of your skills. It is not a biography of your work. You create (and send) resumes because it’s a required step for the purpose of the application, not because it’s particularly convincing. In the long run, it does very little to make the case for hiring you. After all, people could (and do) write literally ANYTHING on their resume, and there’s no way to validate it until the hiring manager… wait for it now: Sits down and talk with the candidate! This brings me to my main point: A resume serves EXACTLY one purpose: to entice the recipient to call you for an interview. If you could send a blank page that said “will bring cookies and beer,” and it would result in a phone call, you should do that. (Do not do this. It doesn’t work. Don’t ask me how I know.) Therefore, your primary goals – which will inform both the format and the content of the information you share – are to: Get past the automated HR filters every company uses these days so that a real human sees your resume. Entice that human to set up an initial call, where the REAL interviewing will begin. Let’s talk about item #1 first. And I’ll start with a semi-well-known “resume hack”: White Fonting The idea behind the buzzword is simple: you take keywords and/or the job description itself and include it in your resume, using the smallest font size possible and coloring the text white, rendering it invisible to the human reading the page; but the text still registers with the automated systems that ingest and auto-scan the resume. The required keywords are detected, and the resume is passed to the next stage. Sometimes. Sometimes, the text actually messes up the experience section on the application, causing the resume to be rejected when it might have otherwise passed. In other cases, a human sees what’s happened and rejects the resume because it’s perceived as “cheating.” (My personal feeling is that using software to auto-filter resumes is cheating, and cheating a cheat is basically Kobayashi Maru-ing the thing, and I’m 100% team Kirk on this.) That said, it’s clear (to me, at least) that white-fronting is neither reliable nor guaranteed, but it does work in some cases. Use with caution. Sometimes, It Is Who You Know As I’ve already explored, there is a demonstrable value to having someone on the inside to help shepherd your resume along the application journey. Internal referrals often give your resume an automatic pass to the first real (hiring manager) interview stage. Even when it doesn’t, at the very least, it increases the likelihood you’ll get feedback if you don’t make the cut. If you don’t know anyone at the company in question, it’s time to trot out your LinkedIn skills to find people who know the people you need to know. Get introduced. Offer to buy someone in your targeted group/department/specialty a coffee and pick their brain about the company and work. Don’t fish for a job; reach out for a conversation. Once you’ve met and allowed them to understand who you are and what you are about, THEN you can express interest and ask if that person would be willing to give you a referral. You Get What You Give Be prepared to customize your resume. Highlight (or, in some cases, re-write) the resume to accentuate the needs expressed in the job description and de-emphasize elements that are less important. Does that mean more work for each job application? Yes. Should you do it for every single job? OF COURSE NOT. You’d do this for the high-value opportunities, not the “this came up as I was scrolling LinkedIn” jobs. But remember that the effort you put into an application very often reflects the value of the outcome. Not always, but often. For the second part, I am going to emphasize that in every place you can quantify a result, you need to do so. It’s Not What You Said; It’s How You Said It Again, a resume is not just a list of “I did this sh…tuff.” It should convince the reader that you are able to produce results FOR THEM. By measurably quantifying the effects and impacts of your past work, you implicitly state your ability to do the same for them. Consider the difference: “Cultivated a healthy work-life balance culture for both in-office and remote employees by creating groups and events for in and out-of-work activities,” vs. Improved employee satisfaction stats by 5% YoY by creating groups and events for in and out-of-work activities, with an average of 65% attendance over 2 years. Increased product visibility by integrating a new records management system to become a more competitive offering for new clients vs. $5k revenue increase MoM for the first 3 months and +30% adoption rate by integrating a new RMS, making the offering more visible, competitive, and valuable. Obviously, you might not always have numbers for the things you’ve done. This suggests a few things to me: Start making a habit of noting these types of results – not just because it looks good on a resume, but because the business you work for now is ALSO interested in these types of results. Challenge managers to provide these types of outcome statistics and question work when no perceivable value can be attained. As you are writing or updating your current resume, note the items where you can offer ranges, where you can stand by terms like “significant increase” or “measurable impact,” and which items simply defy quantification. For those items that have no measurable outcome, consider why you’re including it. Again, “At my old job, I did stuff” is not a compelling argument to hire you. Sure, you need to show that you have experience with a specific language or technology. But “I know how to do things” or “I can learn how to do things” can be communicated in other ways besides taking up valuable inches of resume space as a laundry list of tasks. Separate and Elevate Consider separating the work result from the work history. Have one section for “Places I Worked” that simply lists dates, company names, and job titles. Then disassociate the tasks from the job by grouping them based on technology, result, or some other category. Nobody really cares that you did these things at company X, but those things at company Y. It’s more interesting to see all the ways you’ve used Java to create results or your various improvements to team productivity. By grouping the work you’ve done by category, you create a compelling picture of your skills. The (Mostly) Un-Necessary Summary You need to trust that the interview(s) will reach out to you and ask for specifics, or background, or context. In fact, a well-designed resume will cause the reader to wantto do exactly that. As always, I hope this helps. If you have additional questions, contradictions, or corrections, leave them in the comments.
Do you know what the global edtech and smart classroom market size was in 2022? No idea? Then, we must inform you that it was somewhere around USD 115.80 billion, which is estimated to grow from USD 133.55 billion in 2023 to USD 433.17 billion in 2030. Yes, you read that right! And among all the contributors to these numbers, Physics Wallah has been a well-known name. But did you know that there was a time when this edtech brand launched its app for the first time, and it crashed because a myriad of authorized users logged into the application simultaneously? In short, the concerned app failed to meet the growing demand of users due to its poor performance, scalability, and resilience, resulting in a huge loss to the business. Now, if you don’t want to experience the same by hook or by crook, you must rely on scalable digital products. Yes, only when you do that will you be able to develop a powerful digital product that can survive and thrive in the market easily. But the query pops up: what are scalable products, and why should you use them? Well, to get a good sense of that, you will have to browse through the next text stack. What Do You Mean By Scalable Products? These products generally refer to the ability of a software application to handle the upsurging demand, complexity, or use of the mobile program without affecting its quality, performance, and functionality. Product scalability is one of the key factors that determines the success and growth of any virtual application out there. Since not all digital products are good at scalability, a stunning survey by a business-focused media organization has found that only 8% of agencies succeed in scaling during their operation. Can You Give Some Examples of Scalable Digital Products? A case in point here is that John Young has showcased the RS/6000 SP operating system as a scalable system in one of his books named “ Exploring IBM’s New-Age Mainframes.” But why? You might want to know. Well, it is because of the ability of RS/6000 SP to retain performance levels even after adding extra processors. Another example of scalable products on this list is scalable fonts. Yes, you heard that right! In the printing domain, scalable fonts can be resized effortlessly depending on the requirement without losing their quality. With that over, it is time to grasp imperative information about: Why Should You Focus On Product Scalability? Honestly speaking, if you wish to grow and fulfill the increasing demands of your users while staying competitive in the market, it makes sense to make your product extensible. Let’s delve deep into the details: Meet Growing Demand Horizontal scaling lets you connect a higher number of devices or servers to your existing infrastructure in order to cope with the increased traffic and allocate the load evenly. On the other hand, vertical scaling concentrates on upgrading current hardware to better performance and potential during scalable product creation. Improve Performance And Reliability By taking the plunge to distribute the workload across various servers or implement load balancing techniques, it becomes a breeze to: Minimize latency Manage peak loads efficiently Guarantee a seamless user experience Perform Effective Capacity Planning Some industry experts say that when you have scalable digital products at your disposal, the chances are high that you can precisely anticipate resource requirements and distribute them accordingly to ensure excellent performance and steer clear of overprovisioning or underutilizing resources. Thus, if you are willing to fabricate a mobile app that can grow with your business down the road, you must have a casual conversation with the dedicated representatives of a top IT service provider that delivers promising app development services. When Should You Build Scalable Products? Being a responsible app owner, it is necessary to sell your offerings and live up to the expectations of your consumers in terms of features and performance. Although product scalability was not your priority years ago, it is the need of the hour to scale your deliverables to support its growth. And one of the clear signs of the need to extend your product is when its performance starts deteriorating. For instance, a software application might show a degraded performance when a battery of users begins using it at the same time. That’s when you need to take a look at key metrics, such as: Memory utilization CPU usage Disk I/O Network I/O If any of them needs further improvement to take care of the increased load, you must fulfill the same. What else? Some industry specialists suggest analyzing wads of indications proactively to figure out when to proceed with product scalability and when not. By doing this, you won’t have to wait for your app performance to drop big time. Instead, you will be able to optimize the same before time. Beyond this, you can ask yourself a few important questions: Do you have a business value to deliver to a massive consumer base? If so, there is plenty of scope for your business to grow, and you should invest adequately in your product scalability. Have you built an outstanding product already? Did you receive the feedback of your desired market that confirms you have a superb product? If the answer is yes, do not hesitate to expand your product. Please remember that forming scalable apps is not everyone’s cup of tea. And if you can’t forge a scalable application properly, you can’t expect to achieve aggressive growth and generate considerable revenue in the future. Perhaps this is the reason why a popular insight-delivering firm has found in its research that less than 0.01% of all customer-based mobile programs had an opportunity to become financially successful in 2018. Finally, it is time to discuss the most awaited topic in this write-up, i.e., How To Carry out the Entire Product Scalability Task Make the Most of Customer Feedback and Data Collection Quantitative analytics and research are two impeccable methods to collect buyer feedback that can make you aware of a successful expansion plan. By paying attention to their responses, you can learn which functionalities to add to your scalable products next and then optimize and retest. With such a plan at your disposal, you can rest assured that your application will keep evolving and adapting to market demands in the time to come. For example, it will help if you gather actual data from users when they use your software during the MVP stage. Keeping track of user behavior, user journey, drop-off, and interactions at every touchpoint can help you recognize functionalities that can be improved, added, or deleted from scalable digital products when moving from the MVP stage to the complete launch. Be mindful that it is necessary to go through all the positive and negative comments and find a way to address them. Wondering why? Well, it is unsatisfied clients who will highlight the issues in your app that you can sort out when shifting from the MVP stage to full-fledged scalable product development. And in case you need some sort of technical assistance to create a scalable application, you can always count on a trusted IT service provider on the cloud with expertise in software development services. Choose the Correct Database Engine The next thing you must do is pick the most appropriate database engine and create an exceptional plan or model to ensure your product scalability takes place without any hassle. Hence, when the demand boosts, you will be prepared to process a sizeable number of transactions using this approach easily. Keep in mind that replicating your database could be the perfect idea when your web app scales. And just to let you know, this replication process entails imitating the database so that its several copies exist, and each one can look after a subset of the CRUD (Create, Read, Update, Delete) tasks. It is an accepted practice in the industry to divide the read and write operations of the databases when creating scalable digital products. Put APIs First You might not believe this, but the truth is that the advent of API-first software architecture has been one of the most useful innovations in the field of software design. Earlier, APIs were manufactured as an afterthought to existing applications and were complicated, too. Nowadays, an API-first design actually separates them from the beginning, allowing teams to quickly build experiences and products compatible with several endpoints. The API-first methodology insists on tapping Application Programming Interfaces to join all platform parts and transfer crucial data between them when making scalable products. Call on Continuous Integration and Continuous Delivery Just like Agile soars productivity, CI/CD procedures take the same to an even better level, ensuring rapid release of scalable digital products with fewer issues. The key is the large-scale adoption of continuous automation throughout all stages of development, which results in a more streamlined and consistent development of code. This is something that acts as an imperative process when looking to integrate new functionalities or execute product scalability tasks. You might have seen many software developers working in parallel these days on web app development projects, which takes productivity to the next level and also boosts the likelihood of bugs. If this happens, you will have to spend an enormous amount of time bringing together different pieces of the program that have been constructed by different developers out there. However, the good news is that this trouble is being fixed with the help of CI/CD tools. Now that you have wrapped your mind well around the right method to scale a digital product, it is time to get down to the last but most important topic from our point of view, i.e., What Is the Cost of the Entire Digital Transformation Project? Just so you know, each transformation project is unique and different. The total cost to develop fully scalable digital products will vary depending on the following: Your organization Its industry The type of transformation required A wide variety of other factors According to a premier online knowledge resource focused on the CXO, the average digital transformation project can set you back by $27.5 million based on a 2020 report. If you want to get the hang of the expenditure required to work on your specific product scalability task, it is a wise decision to connect to the most knowledgeable executive of a renowned IT service-providing agency. The Rundown So far, you have come to know how imperative it is to make your product scalable as time goes by. Right? Because with every passing day, the needs, preferences, and expectations of patrons keep changing. If you are in the market to provide them with the best possible product or service, you also need to ensure that they can access the same anytime and from anywhere they like. But to guarantee the same, you will have to come up with completely scalable digital products that can cater to hundreds of thousands of consumers at the same time. For that, it is advisable to collaborate with a well-established IT solution provider now that has a specialization in scalable product construction.
Comparing the backend development landscape of today with that of the late '90s reveals a significant shift. Despite the fact that the barriers of entry to software development as a career have become lower, the role is now more complex, with developers facing a broader range of challenges and expectations. Engineers today grapple with building larger and more intricate systems and an overwhelming amount of choice across all aspects of software development. From which language, tool, platform, framework, etc. to use, to which solution, architectural style, design pattern, etc. to implement. The demand for designing robust, scalable, and secure distributed systems capable of supporting thousands of concurrent users, often with near-perfect availability, and compliance with stringent data-handling and security regulations, adds to the complexity. This article delves into the ways backend development has evolved over the past 20 years, shedding light on the aspects that contribute to its perceived increase in difficulty. Higher User Expectations Today's computers boast exponentially greater memory and processing power, along with other previously unimaginable capabilities. These technological leaps enable the development of far more complex and powerful software. As software capabilities have increased, so too have user expectations. Modern users demand software that is not only globally accessible but also offers a seamless cross-platform experience, responsive design, and real-time updates and collaborative features. They expect exceptional performance, high availability, and continual updates to meet their evolving needs with new features and enhancements. This shift challenges developers to leverage an array of technologies to meet these expectations, making backend development even more challenging. Increased Scale and System Complexity The complexity of software problems we tackle today far surpasses those from 20 years ago. We are now orchestrating networks of computers, processing thousands of transactions per second, and scaling systems to accommodate millions of users. Developers now need to know how to handle massive, polyglot codebases, implement distributed systems, and navigate the complexities of multithreading and multiprocessing. Additionally, the necessity for effective abstraction and dependency management further complicates the development process. With complex distributed systems, abstractions are essential to allow developers to reduce complexity, hide the unnecessary details and focus on higher-level functionality. The downside of the widespread use of abstractions is that debugging is much more difficult and having a comprehensive understanding of a system much more challenging, especially due to the limitations of traditional system visualization tools. Furthermore, the proliferation of APIs necessitates meticulous dependency management to prevent the creation of systems that are convoluted, fragile, or opaque, making them challenging to understand, maintain, or expand. Although many developers still resort to whiteboards or non-interactive diagramming tools to map their systems, recently, more dynamic and automated tools have emerged, offering real-time insights into system architecture. These changes, along with many others (e.g. heightened security requirements, the introduction of caching, increased expectations for test coverage, exception handling, compiler optimization, etc.), underscore the increased complexity of modern backend development. The era when a single programmer could oversee an entire system is long gone, replaced by the need for large, distributed teams and extensive collaboration, documentation, and organizational skills. Overwhelming Choice With the rapid pace that technology is evolving, developers now have to navigate a vast and ever-growing ecosystem of programming languages, frameworks, libraries, tools, and platforms. This can lead to decision paralysis, exemplifying the paradox of choice: it is a mistake to assume that if we give developers more choice, they will be happier and more productive. Unlimited choice is more attractive in theory than in practice. The plethora of choices in the tech landscape is documented in the latest CNCF report - which shows hundreds of options! While a degree of autonomy in choosing the best technology or tool for a solution is important, too much choice can lead to overload and ultimately overwhelm people or cause procrastination or inaction. The solution is to strike a balance between providing developers with the freedom to make meaningful choices and curating the options to prevent choice overload. By offering well-vetted, purpose-driven recommendations and fostering a culture of knowledge-sharing and best practices, we empower developers to navigate the expansive tech landscape with confidence and efficiency. Different Set of Skills The advent of cloud computing has introduced additional complexities for backend developers, requiring them to be proficient in deploying and managing applications in cloud environments, understanding containerization, and selecting appropriate orchestration tools. Besides technical knowledge, skills in modern backend developers that are particularly valued are: Managing legacy software and reducing architectural technical debt. The majority of projects developers work on these days are “brown field”. Knowing how to adapt and evolve architectures to accommodate unforeseen use cases, all the while managing — and possibly reducing — architectural technical debt is a prized skill. Assembling software by choosing the right technologies. With the explosion of software-as-a-service (SaaS) and open-source software, software development has shifted to an assembly-like approach, where backend engineers need to meticulously select and combine components, libraries, and frameworks to create a complete system where each piece fits seamlessly. Designing a scalable, performant, and secure system architecture. Backend software engineers are designers too and they must possess a deep understanding of software design principles to create scalable and maintainable applications. Cross-team communication. Distributed systems are built by large teams that comprise many different stakeholders. A sign of a great engineer is the ability to communicate effectively, fostering a shared understanding and efficient decision-making across all stakeholders. Conclusion In reflecting on the evolution of backend development over the past two decades, it becomes evident that the role has transformed from a relatively straightforward task of server-side programming to a multifaceted discipline requiring a broad spectrum of skills. The challenges of meeting higher user expectations, managing the scale and complexity of systems, navigating an overwhelming array of choices, and acquiring a diverse set of skills highlights the complexity of modern backend development. While it has never been easier to enter the field of software development, excelling as a backend developer today requires navigating a more complex and rapidly evolving technological environment. Possessing expertise in system architecture, cloud services, containerization, and orchestration tools, alongside the soft skills necessary for effective cross-team communication, will remain pivotal for success in this dynamic domain.
Fix: Developer Chasm To Engage More Devs With My Open Source Project Wish I could push that git commit to move beyond initial developer engagement. A developer chasm means getting stuck with open-source community growth after initial engagement. In this article, I will share the insights that helped me successfully move open-source projects from the initial developer engagement stage to the category leader stage with community-led growth. I learned from my developer community-building work and developer relations consultant work for open-source projects. A quick note if you’re hearing the term “Developer Relations” for the first time.Developer Relations or DevRel meaning: A work function that covers the strategies and tactics for building and nurturing a developer community. What Is the Source of My Learning? The source of my learning for the topic is my experience as a Developer Relations Specialist for open-source projects, building Invide (a remote developers community), organizing Git Commit Show (a global developer conference), and, of course — being a developer myself. You’ll find me quoting examples from these experiences. What Will We Cover in This Blog? What’s not a problem for open-source projects today What is the challenge open-source projects face — developer chasm Case studies of solving developer chasm Five insights to fix the developer chasm Disclaimer: The data mentioned in the post is from Nov 8, 2022. I didn’t update it, as the conclusions are still the same. What’s Not a Problem for Open Source Software Today Open Source Has Already Won Over Proprietary 70–90% of modern codebase is the Open-Source code — Jim Zemlin, Linux Foundation One estimate comes from the Linux Foundation, which found that in 2020, open-source software accounted for 70–90% of the code in any given piece of modern software. This means that the vast majority of software that we use today, from web browsers to operating systems to mobile apps, is built on open-source code. Open Source Is Raining Public repositories on GitHub [Data Source: GitHub, Nov 8, 2022] Total public repos — 43M Created in 2022–12M (27% of total) As of today (Nov 8, 2022), there are more than 43 million public repositories on GitHub. A significant number of these public repositories can be counted as open-source software (we will come back to those numbers later in this post). The key data point to notice is that 12M new public repositories were created this year itself. That’s a huge 27% of the total public repositories. A big number. And we love that, don’t we? Starting an Open Source Project Is Easy 1. Build a Useful Software: Easy If you compare the efforts it takes to build a web app or an automation system in 2023 vs. 2000, it would seem pretty easy to build software these days. There’s already a huge ecosystem of useful open-source software for the majority of common developer needs. There are 43M public repositories on GitHub as of now, out of which a huge 6.1M are MIT licensed, and 2.2M are Apache 2.0 licensed. The tech education is available in abundance over YouTube and blog content. The support is quite easily available on GitHub, Stack Overflow, Reddit, Discord, etc. DevOps tools and cloud services further make it easier to test and iterate faster. So making a software that takes the existing system one step further is not hard. If you have an idea and average programming skills, you just need to get started, and code it. 2. Make It Open Source: Easy Even before you take the first step to build something, you can publish the first commit easily on GitHub or any other source code hosting platform. Git has matured so much that you don’t need to think about how you will deal with source version control. Many licenses have been standardized to cover various cases of ownership and distribution rights for your code. So it is only a matter of making the decision to open-source and a couple of minutes to actually do it. 3. Engage Some Early Users: Easy It is not rare to see that projects get decent early engagement as long as there’s a need. This year itself, there have been 7000 new Open-Source GitHub repositories that received more than 100 stars. That’s a decent amount of engagement for a new project where some early adopters are considering the product to explore further, asking questions, reporting issues, etc. 4. Engage More Developers: Hard Falling on your face after a decent achievement. When you go beyond that first release and the first 100 GitHub stars, the challenges start appearing in making it a bigger project. Starting is easy; making it meaningfully big is hard. Is it true? Let’s discuss that with some data. The Problem Open-Source Projects Face Today: The Developer Chasm Only 1/128 GitHub repos with 100+ stars has 5k+ stars To understand that, let’s first understand how many devs engage with an open-source project. We will take the count of GitHub stars as a proxy for the number of developers considering exploring the project. Out of 12M repositories created this year, 7000 projects have 100+ stars, and only 55 projects have 5000+ stars. It means for every 128 projects that have 100+ stars, there’s only one that has 5000+ stars. In other words... For every 128 open source projects that were able to engage 100 developers, there’s only one that was able to engage 5000+ developers. Some more stats that showcase the exponential difficulty in getting GitHub stars (proxy to developer engagement) for public repositories: This year, by now (Nov 8, 2022), 12M new GitHub repositories have been created Out of which 70k had 10+ stars 1/10th of those 70k i.e. 7k had 100+ stars Only less than 1/14th of these 7k i.e. 500 had 1k+ stars 55 received 5k+ stars And only 15 new GitHub repositories received 10k+ stars this year No. of public GitHub repositories vs the no. of GitHub stars. [Data Source: GitHub, Nov 8, 2022] The Problem: “Developer Chasm” Getting Stuck After Initial Engagement From the stats presented in the previous section, we can conclude that it is exponentially harder to engage more developers with your open-source project beyond the initial engagement. From my experience as a developer, startup founder, and DevRel consultant for open-source projects, I have seen this pattern everywhere. You create initial versions of your open-source project, share it with some friends and communities, get some decent engagement and feedback, and probably do some more iterations of product and developer engagement strategies. And then you’re stuck there; it looks like you’ve been slowed down by an uphill path right after a smooth ride on a plain highway. You wonder how to engage more developers with your project in order to make it a category leader. This is the challenge this post aims to solve. And that’s the problem we aim to solve in this post from a DevRel perspective. I say this “from a DevRel perspective” because this problem has been well documented from other angles but not from the angle of DevRel. For example, the book “Crossing the Chasm by Geoffrey A. Moore” mentions the same challenge as “The Chasm” using this popular graph: The key concept mentioned in the book: The chasm is the gap between the Early Adopters and the Early Majority. This is the point in the technology adoption lifecycle where a new technology must prove its value to a larger audience in order to achieve mainstream success. Companies that are unable to cross the chasm often fail to achieve their business goals. As in our case, we’re focused on open-source product adoption by developers,Let’s refer to this challenge of moving from early adopter to early majority phase as— “developer chasm.” You see that innovators section in the graph, that’s your audience who engaged with you when you first shared about your project publicly. And then you attempted to attract early adopters and either failed to do so OR found it hard to move to the next phase, the magical phase of “early majority.” The book spills the wisdom on strategy about how to solve this from a broad perspective with key ideas such as: Repositioning the product Finding the winning niche category Building relationships A must-read book. Great advice for any tech product. On the other hand, this post will provide a more detailed view of how to solve this challenge with DevRel strategies and tactics independent of product decisions. What can your Developer Relations team do to leap from this developer chasm? Is It Even Possible for a DevRel Person To Solve the Developer Chasm? More than often, you’ll find people labeling success as luck, being in the right place at the right time. Some people will say, “Build a great product, and they will come.” Do products that have been improving at a great speed also struggle with the same challenge of getting stuck after engaging those initial users? In my experience, yes. Even the projects that are improving quickly also face the same challenge. And this turns into a loop where it is even difficult for products to improve without continuous engagement and feedback from users. So engaging more developers beyond that initial engagement makes or breaks the project. What can open-source maintainers do about it? Case Study #1: Open-Source Project That Rose Like a Phoenix I was lucky enough to work on this open-source project that had become stagnant after the initial growth. The competitor (in blue) also had a similar story — after the first huge growth, it was not growing at a rate that the team would be excited about. But within two quarters, a series of decisions and activities led our project to experience that hockey stick growth beating the competition that had been around for some time. It reached that 10k stars mark quickly. The learning: It is possible to solve that challenge of growing beyond first initial adoption. Case Study #2: Community That Engaged 15K Experienced Developers In 2016, I started building an invite-only community of remote developers. As with other projects, initial adoption was great. 100s of experienced joined our chat channel, but then, it stopped moving beyond that initial growth. Fast forward to 2.5 years later, we had engaged more than 15k experienced developers. What made all these things possible? When I think about that, these are the points I came up with: 1. Start With the Decision to Focus on One Metric Solve one problem at a time. If you have focus, half the battle is won already. More often than not, I find open source project authors/teams making this mistake, especially in the Developer Relations team; they want to do everything at once and many times work on (or not let go of) projects just because of FOMO (fear of missing out). It’s important to remember that you can’t improve everything at once. So, start by focusing on one problem at a time. Once you have made some progress on that problem, you can then move on to the next one. I have seen the benefits of focusing on one metric and the downsides of having multiple metrics to focus on. Before we dive into how to choose the right metric, let’s take a look at some of the examples of the metrics I had chosen in my Developer Relations projects Metric Example 1: # Of GitHub Stars Get to the 5k GitHub stars mark within 2 quarters We chose this metric to aim for the key business goals: Break out of stagnant growth period Build better public/investor perception of the project’s growth Example 2: # Of Support Messages Increase the number of new support messages by 20% within a quarter. We chose this metric to aim for the key business goals: Increase community engagement Understand the community use cases, needs, and the challenges Example 3: # Of Interviews Conduct 250 `1:1` interviews within 2 quarters We chose this metric to aim for the key business goals: Get verified talented developers in the community, controlling the community diversity and the needed characteristics of the members Understand their needs/aspirations How To Choose the Right Metrics? Start by asking: What matters the most right now? What will matter in the coming 6 months or a year? Then, come up with a list of different metrics that can reflect the goal progress and check which ones are: Aligned with the business goal Simple to understand Easy to track Remember, deciding the metrics is an art, and experience helps. Some examples of metrics to choose from: GitHub stars GitHub repo traffic # of new Slack/Discord members Followers on social channels Comments on social channels GitHub forks Beware of metrics such as: Docker pulls: Inaccurate data, especially due to CI/CD and automation pulls, which are not in small numbers Telemetry sourced metrics: Privacy concerns are not easy to tackle, and this leads to incomplete data. And no, don’t think about defaulting to opt-in; you do not want to piss off your community 2. Simplify the Communication I was working with this open source projects’ team, which had tried to engage developers on Reddit in the past, but it did not work well for them. When I proposed to do this again, the team was reluctant to do so because of past failures. Anyway, I started doing it, posting and analyzing one post at a time, and slowly, the engagement on my Reddit posts started improving. Eventually, this led to multiple viral engagements. What change did I make that started giving better results on the same channel? The communication. Let’s take a look at the communication before and after Before Simplifying One of the early posts. No engagement at all. Before simplifying communication After Simplifying One of the later posts with decent engagement. Look at those numbers of upvotes, and even more valuable than that — the % of people who viewed and upvoted: 96% (as compared to the prev. one, which had a 57% upvote rate only). After simplifying the communication and tailoring it to the audience's needs and style Why did it work way better than the earlier communication? While looking at the change, you might be tempted to make a conclusion — it is a simpler message, it is easy to understand for a broader audience, it showcases the value upfront, etc. While all those arguments are true, I still believe there’s no magic formula for communication that can result in better outcomes despite following these best practices. But what has always resulted in a better outcome is the process of refining the communication. Starting from wherever you are and taking the next steps to make it simpler and more interesting. How To Make Your Communication Simpler and More Interesting for Developers? Before you start working on this, one thing that needs to be understood is that the business pitch and the developer pitch are different. The way you communicate to each of them is not just slightly different but a totally different way of looking at the communication. The person taking care of the business (e.g., CXOs, execs) cares for different kinds of problems, and the developer cares for different kinds of problems, not just related to technical problems but problems in life in general as well. They could be the same person acting like both, but nonetheless, you should consider them two different personas to serve. This is why keeping the DevRel function separate from Sales is key to nailing both types of communications. Start thinking for this developer audience from the ground up, and start thinking about the problems they face in their lives. Your content will usually solve those developer problems or at least show that you care about them. But how do you go about figuring out those problems, and what does the process of refining this communication look like? The process to refine the communication, I like to call the funky QUAKE — Question Understand Answer, Keyword Experiment. Sometimes, I like to call it DevQuake, as in an earthquake. See, I haven’t been sharp at naming things, whether it is a variable in programming or an abbreviation to remember a process, open to ideas :) Questions: Start with looking at the questions people are already asking on StackOverflow, Reddit, developer communities, events, and anywhere you believe they will be asking questions. Usually, these questions will be in the form of “how to do/fix/create X”. There are many more types of questions that you’ll discover along the way. Soak that information in. Understand: From these questions, understand different problems or confusion they have. Not only the problem your product solves but also pay attention to all adjacent problems indirectly related to the key problem you solve, related to your category. Read between the lines. Note it down. This research will come in handy later. Answers: Answer those questions on internet forums. The activity of answering those questions will bring you one step closer to how your audience thinks and why they think that way. It will help you think on a deeper level about your developer audience's needs and behavior. Keywords: Understand the keywords/style your early adopters use. Understand how they describe their problems, what keywords they use to explain their problem or expected solution, what keywords do they already understand, what knowledge do they already have about your category, etc. But mainly, it is about the “Keywords”. Experiments: Experiment with new communication angles and then listen. It could be in the form of an educational post; it could be a simple question you might have; it could be an ask for help/feedback; it could be a celebration of a problem/solution, it could be something topical, it could be something inspirational, it could be a long rant, it could be in any form — text, image, video, etc. It could be the same communication but to a different kind of audience, etc. The bottomline is to be bold in experimenting with new angles. If you keep following this for some time, you’ll see that your communication with your target developer audience is getting better. You’ll soon start seeing the impact of these improvements on the growth/engagement metrics. 3. Engage With Developers Wherever They Are I find many DevRel folks waiting for targeted developers to join their product community and only then they help them out. This is not a good strategy, in my opinion, and leaves room for competition to engage those people who either don’t know about your community or don’t feel the need to join your community. Instead, go out and engage with developers on external communities/forums, asking questions related to the problems your product solves. This will build your reputation as an expert and bring those people to engage with your community. Learning: “Don’t wait for them to come to your community, have conversations with devs outside your community as well.” Another limiting belief I see is related to how you decide on the external communities/forums where you decide to engage. Most of the time, I see that open source authors or their DevRel team have too narrow a focus, e.g., if they have a search product, they usually focus only on search-related communities; if their target audience is backend engineers, they focus only on backend engineer-related communities. This leaves a lot of missed opportunities to engage developers. Instead, you should be thinking about a holistic picture of all the different things your target developer audience might be interested in. Aren’t there backend developers who love Chess or Rick and Morty? Some developers don’t even take part in a backend developer community, but they will participate in a chess community. Learning: “A developer is more than just a developer, a human being with varied interests. engage with them wherever they are.” Example: Think Outside the Box I engaged developers for a search-related product in a data visualization community. These two things do not seem connected, but I asked a simple question — are there some developers who love data visualization? The answer is yes. Of course, not all data visualization lovers are developers, but if my post goes viral, will it engage some of those developers who are part of this community? The answer is yes. That’s what happened: the post went viral, and we got a huge number of GitHub stars from that activity. I had to think outside the box to come up with a communication for that community that would be relevant to everyone in that community and would attract our target developer audience. A post on a seemingly unrelated community When engaging with external communities (e.g., HN, SubReddits, Meetups, etc.), you need to keep some things in mind so you do not end up pissing your target developers off. Be someone who adds value, not the one who keeps spamming everywhere. And there are some principles that I follow to make sure I am the former one: Understand first, then try to be understood. First understand that community, why people come here, what do they like, what kind of content do they engage more with, etc. Although, there are some hacks but it still takes time to do that, you gotta do that, there’s no other alternative. No more than one team member in a community. When you have more than one team member in an external community, you will end up coordinating to make your post look good. You will end up spamming when you both are in sync with what the other person is doing. All of this is not good for your project, and you’ll piss some people off and do more harm than good. The solution is simple — one community, one person. Be the first one to start the conversation. The ego will kill your project. I have seen many DevRel folks, who try to play hard balls to make a perception about their project/team. It is useless and does the opposite. Have the humility to be the first one to start the conversations. As simple as that. Notice what they say and what keywords they use. We have discussed that before. Keep your eyes and ears open. Individuals over teams. Developers in communities hate people who say, “We did this,” “We are so cool,” and so on. Instead, think from an individual perspective and communicate your authentic thoughts from that angle; people will be able to relate to that. For example, I never say, “We released a new version of our project; it has these cool x, y, z features.” I would rather say — “I have been working on this project for x months, and I’m excited that the new version goes out today with features I contributed, such as y and z features.” I bet that more people will engage with your second communication. Being authentic is never outdated and is a key to communication that makes an impact. 4. The Mindset: Obsess With Transparency and Ask For Help “It is a common false belief that in order to build your authority, you should not expose your vulnerability or ask for help.”– Pradeep Sharma Case Study: Turning a PR Disaster Into an Opportunity Imagine you’re launching your open-source project’s key release after months of hard work. You’re showcasing it in front of an audience of 200+ people in a professional live event. All of a sudden, someone hacks the event and starts playing racist music and drawing vulgar sketches, and you have to end the event there. This is a major PR disaster and disappointment for the team. It pisses off your team, the contributors, the investors, and everyone else who was attending the event. But later, when you approach this with humility, authenticity, and transparency, not hiding your vulnerable side, accepting your failures, and asking for help, this becomes one of the important reasons behind your exponential community growth. Here’s the link to this full story. After the dust settled Authenticity pays off So what is the learning here? The mindset. The mindset of the open-source project owners can be a slow poison that kills the project silently, or it can be a weapon that drives growth. One mindset is to showcase only stuff that makes you look good, and one mindset is to showcase everything, irrespective of how it makes you look, for the sake of transparency. If I had tried to hide our PR failure, I wouldn’t have built trust with the community. Why Obsess With Transparency? If you’re running an open-source project and don’t obsess with transparency, you’ll never build the needed trust in the community (whether internal or external community) to drive your project beyond that first level of engagement. Transparency is the key DNA element of any open-source project. This DNA makes it competitive with proprietary alternatives. This openness encourages a sense of community and shared ownership. There is a reason why developers trust open source more than proprietary software — transparency. Transparency builds trust. It starts with showing your code in public; irrespective of whether it is good or bad, you put it out there for everyone to see. But this transparency should not end there; it needs to be reflected in every aspect of running an open-source project, including the DevRel function. One key reason is that not everyone has the time to go through the complete code (and the later revisions) to make an objective judgment about how much they can trust your project. They will use the transparency you show in your communication to measure how much they can trust you. I am talking about genuine transparency, not the one where you share all good things and when something bad happens, you go silent. You are not doing anything unfair by going silent in that moment but you’ll never earn the trust of the community this way. The way I measure transparency — how many times in a year do you share the news that you don’t need to in order to look good. Why Ask For Help? There’s a sureshot way to not get any contributors for your open source project — do not ask for help. If you don’t ask, they won’t come. But the same feelings that stop you from becoming more transparent also stop you from asking for help when you should — fear of looking bad. Asking for help is not a sign of weakness, but a strength. No one person has all the answers, and the beauty of open source lies in its collective intelligence. By asking for help boldly, you can tap into the knowledge and wisdom of the community. Asking for help empowers them with an opportunity to step up and take responsibility, fostering a sense of ownership and engagement. Transparency and the willingness to ask for help are not just nice-to-have qualities in open source projects; they are essential. Key points to remember: Transparency is not about “sharing all the good news.” Vulnerability builds emotional connection Why would someone help if you don’t need it 5. Scale Developer Education With Content Case Study: Turning the Project To Be Synonymous to Category I was working on this project which wanted to be the leader in the “Neural Search” product category. I turned that open source project to be synonymous with Neural Search. What I did was this — I wrote one blog post and one video educating about the category of the product “Neural Search” and distributed that content well such that 75% of the first-page search engine results were my content. If you as a developer were to research what “Neural Search” is and how to go about implementing it, you’re likely reading/watching my content. This content engages more developers with that open-source project even after 2 years. Dominating search suggestions Dominating Google’s rich cards “People who ask.” Dominating the search results for the main product category keyword There were some more decisions involved in this overall achievement; let’s understand them. Developers don’t like to be sold. They are the smartest people to detect BS on the internet. You telling them about your product is a form of BS for them, it has little impact on their decision making. If you’re banking on telling developers about your product, you’ll struggle to get any meaningful adoption or scaling up your developer engagement. Developers will always do their own research and make a judgment from there. But once their research reaches the conclusion that your product is actually a good choice for their use case, it will bring more users. Because they will share their genuine research outcomes with their colleagues, their future employers, users on internet forums, etc. And that’s what other developers will see as non-BS content. It is a slow process, and you can speed it up a bit by creating non-BS content yourself. But what is non-BS content? Educate your developer audience that can help them with their research. But what should you educate your developer audience about? Common answer I hear — about my product. It is the wrong answer. By teaching developers about your product, you may get some users if you’re lucky, but you’ll never get meaningful adoption and will never be the category leader. Instead, do this: Pick the category that you want to lead Educate your targeted dev audience about this category Retarget that developer audience (whom you taught about your category) and educate them about your open-source project now Conclusion We discussed the good and worrisome aspects of developer engagement for open-source projects. We also discussed an approach to overcome the challenge of getting stuck after initial engagement. These insights may help you grow your open-source project, become a better DevRel Engineer, or just get one step closer to becoming a top Developer Advocate (a DevRel expert). In summary, how to engage more developers with your OSS: Focus on one metric Simplify the communication Engage wherever they are Obsess with transparency, ask for help Scale with developer education content
Numerous developers embark on their tech journey only to find themselves disoriented, intimidated by coding sessions, and wrestling with the notion that they might not possess the quintessential programmer's mindset. The path they tread is fraught with challenges, stemming not only from a lack of proper experience but also from the absence of essential tools. Crafting exceptional software is no small feat. It demands an extensive repertoire of knowledge, an eye for detail, astute logical reasoning, relentless research, and, most crucially, time. Developers are perpetually swamped, striving to maintain a sharp focus to avert errors amidst their bustling schedules. Indeed, the role they play is both demanding and fraught with responsibility, making dips in productivity almost inevitable amidst the myriad tasks, vast data, and looming deadlines they juggle. In software development, gauging productivity can seem like an elusive task. Ever find yourself wondering where the hours have flown? Or feel daunted by the high expectations set for your projects? Fortunately, there's light at the end of the tunnel. Overcoming these obstacles is feasible, especially with the aid of specific productivity tools designed for developers. In the sections that follow, I'll introduce a curated selection of tools aimed at streamlining workflows and enhancing efficiency for developers. These tools have been phenomenal in the experience of my application teams which boosted their productivity and efficiency. 1. Agile Project Management: Jira Agile methodologies have revolutionized the way we approach software development, emphasizing flexibility, continuous delivery, and customer satisfaction. Jira stands out as a robust tool for agile project management, offering features like sprint planning, issue tracking, and Scrum boards. Why Jira? Jira, developed by Atlassian, has become synonymous with Agile project management for several compelling reasons. Its intuitive interface, coupled with powerful features, makes it an indispensable tool for managing complex software projects. Here’s how Jira has enhanced our productivity: Sprint planning: Jira’s sprint planning tools allow teams to break down projects into manageable tasks, grouped into sprints. This feature was transformative, enabling us to prioritize work, estimate efforts more accurately, and adapt plans swiftly based on changing requirements. Issue and bug tracking: One of Jira’s strengths lies in its robust issue and bug-tracking system. By centralizing bug reports and feature requests, Jira facilitates a more systematic approach to addressing issues, ensuring nothing falls through the cracks. This centralization has significantly reduced our downtime and improved the quality of our final products. Customizable Scrum and Kanban boards: Jira’s flexibility in allowing teams to customize their Scrum or Kanban boards was a game-changer. This customization meant that we could tailor our project management approach to fit the unique workflow of each team, increasing efficiency and visibility across projects. Integration with development tools: Jira’s ability to integrate seamlessly with a wide array of development tools, including code repositories, CI/CD pipelines, and testing tools, streamlined our development process. These integrations allowed for automatic updates and notifications within Jira, bridging the gap between project management and actual development work. 2. Code Collaboration: GitHub The essence of modern development lies in collaboration. GitHub has been pivotal in fostering a culture of collaboration, providing version control, pull requests, and code review functionalities that streamline team-based development efforts. Why GitHub? GitHub goes beyond being a mere repository hosting service; it’s a powerful tool for software teams aiming to collaborate more effectively. Here’s why it became an indispensable part of our workflow: Centralized version control: GitHub provides a centralized platform for our code, offering robust version control capabilities powered by Git. This feature allowed our team members to work on different features simultaneously without fear of conflicts, significantly speeding up the development process. Pull requests and code review: One of GitHub’s most valuable features is its pull request system, facilitating code reviews and discussions right alongside the code itself. This process has not only improved the quality of our code but also provided a learning opportunity for the team, as feedback is shared openly and constructively. Integrations and automation: GitHub Actions and its marketplace of integrations have automated many aspects of our development workflow, from continuous integration/continuous deployment (CI/CD) pipelines to automated testing. This automation saves countless hours of manual work, allowing developers to focus on coding rather than administrative tasks. Open source community: GitHub houses the world’s largest community of developers and open-source projects. This vast network has enabled us to contribute to open-source projects and utilize community-driven projects, significantly reducing the need to "reinvent the wheel" for common functionalities. 3. Continuous Integration/Continuous Deployment (CI/CD): Jenkins In the quest for efficiency, the CI/CD pipeline automates the building, testing, and deployment of applications. Jenkins, with its extensive plugin ecosystem, automates these processes, significantly reducing manual effort and increasing deployment frequency. Why Jenkins? Jenkins is more than just a tool; it's a catalyst for DevOps practices, offering unparalleled flexibility and an extensive ecosystem of plugins. Here’s how Jenkins became a cornerstone of our development workflow: Automated builds and testing: Jenkins automates the process of code compilation and testing, ensuring that every code commit is automatically built and tested. This immediate feedback mechanism allows developers to identify and rectify issues early, significantly reducing bugs in production. Scalable pipeline as code: Jenkins Pipelines allow us to define our CI/CD process as code. This approach not only makes our pipelines more reproducible and version-controlled but also enables us to scale our CI/CD processes as our projects grow. Extensive plugin ecosystem: One of Jenkins' greatest strengths is its vast array of plugins, supporting integration with virtually every development, testing, and deployment tool out there. This flexibility has allowed us to tailor Jenkins to our specific needs, integrating seamlessly with our toolchain. Support for distributed builds: Jenkins supports distributed builds out of the box, allowing us to run builds on different machines, which speeds up the build process and supports parallel execution of tasks. This feature was particularly beneficial for our team, as it allowed us to maximize our hardware resources and reduce build times significantly. 4. Code Quality Assurance: SonarQube Ensuring code quality in a fast-paced development environment is a challenge that every software team faces. High-quality code is not just about reducing bugs—it's about maintainability, scalability, and efficiency. Maintaining high code quality is non-negotiable for productivity. SonarQube offers comprehensive code analysis to detect bugs, vulnerabilities, and code smells, ensuring that quality is baked into the development process. Why SonarQube? SonarQube stands out for its depth of analysis, covering not just bugs and errors but also code smells, security vulnerabilities, and duplications. Here's how SonarQube has been pivotal in enhancing our code quality: Automated code reviews: SonarQube provides automated code reviews, analyzing pull requests for bugs, vulnerabilities, and code smells before they are merged. This preemptive feedback loop has drastically reduced our time spent on manual code reviews, allowing teams to focus on feature development and innovation. Customizable rules and quality gates: SonarQube allows us to define custom rules and set up quality gates based on our specific requirements and standards. This customization ensures that all code meets our defined quality criteria before it's considered ready for production, fostering a culture of excellence. Detailed dashboards and reports: The platform offers intuitive dashboards and detailed reports that provide visibility into the health of our codebase. These insights enable us to identify areas for improvement, track progress over time, and make informed decisions about where to allocate resources for maximum impact. Integration with CI/CD pipelines: Integrating SonarQube with our Jenkins CI/CD pipelines has automated the process of code analysis, ensuring that every build is automatically scanned. This integration has been crucial in embedding code quality checks into our development lifecycle, making quality assurance an ongoing, integral process. 5. Automated Testing: Selenium Automated testing represents a cornerstone in modern software development, particularly as teams adopt faster, more agile methodologies. The shift from manual testing to automated frameworks significantly impacts a team's efficiency and the overall quality of the projects. Automated testing tools like Selenium enable developers to write and execute test cases for web applications, ensuring functionality works as expected, thus reducing the time spent on manual testing. Why Selenium? Selenium’s appeal lies in its flexibility and the comprehensive coverage it offers for web application testing. Below are key reasons Selenium became an integral part of our testing strategy: Cross-browser and cross-platform testing: Selenium supports testing across all major browsers and platforms, ensuring our web applications offer a consistent user experience, irrespective of the user’s choice of technology. This cross-compatibility is vital in today's fragmented digital landscape. Integration with test frameworks and CI/CD pipelines: Selenium integrates seamlessly with various test frameworks (such as JUnit and TestNG) and CI/CD tools (like Jenkins). This integration allows us to embed testing into the development pipeline, facilitating continuous testing and immediate feedback. Support for multiple programming languages: Unlike some testing frameworks that are language-specific, Selenium supports several programming languages, including Java, C#, Python, and Ruby. This versatility meant our team could write tests in the language they were most comfortable with, improving test development efficiency. Open-source community: Being open-source, Selenium has a vast and active community. The availability of extensive documentation, forums, and plugins has made troubleshooting and extending Selenium’s capabilities easier, enhancing our team's ability to implement complex test cases. 6. Cloud Services: AWS The cloud has become synonymous with modern software development. Amazon Web Services (AWS) provides a vast array of services that empower developers to build, deploy, and scale applications with ease and flexibility. Among the myriad of cloud service providers, Amazon Web Services (AWS) stood out for its comprehensive suite of services, reliability, and scalability. Embracing AWS in our projects not only facilitated more efficient development workflows but also unlocked new capabilities that were previously out of reach due to hardware limitations or cost constraints. Why AWS? AWS's dominance in the cloud computing sector is well-earned, offering an extensive array of services that cater to virtually every aspect of computing, from serverless architectures to machine learning. Here are the key factors that made AWS an essential part of our development toolkit: Extensive range of services: AWS provides a wide variety of services, including computing power (EC2), storage solutions (S3), database services (RDS and DynamoDB), and machine learning (SageMaker). This diversity allowed us to tailor solutions specifically to our project needs, often within a single ecosystem. Scalability and flexibility: One of AWS's most significant advantages is its scalability. Services like Auto Scaling and Elastic Load Balancing ensure that our applications can handle variable loads seamlessly, adjusting resources automatically to meet demand without manual intervention. Global infrastructure: AWS's global network of data centers ensures low latency and high redundancy for our applications. This global footprint was crucial for deploying applications that served a worldwide user base, ensuring optimal performance regardless of geographical location. Security and compliance: AWS commits heavily to security, offering tools and features that help us comply with various regulatory standards. The shared responsibility model and services like AWS Identity and Access Management (IAM) have been instrumental in securing our applications and data. 7. Containerization: Docker Docker has revolutionized the way applications are deployed, allowing developers to package applications into containers, ensuring consistency across environments, and simplifying deployment processes.
Expanding on "Build Your Own Programming Language" by Clinton Jeffery, this second edition embarks on an ambitious journey to demystify the intricacies of programming language development. Its inception, driven by real-world application and feedback, signifies a pivotal moment in the dialogue between authors and the programming community. This enhanced discussion delves deeper into the book's multifaceted contributions, exploring its role as a beacon for aspiring language designers and its broader implications for the future of software development. A Responsive Evolution The evolution from the first to the second edition of Jeffery's work illustrates a responsive adaptation to the needs of its audience. The inclusion of a chapter dedicated to preprocessors and transpilers was more than a mere addition; it was a strategic response to the shifting landscape of programming, where the conversion of legacy code becomes increasingly critical. This adaptation not only broadens the book's utility but also reflects a deep understanding of the ongoing challenges faced by developers in integrating old with new, ensuring the longevity and relevance of programming languages. Comprehensive Coverage Jeffery's approach to discussing programming language development is both comprehensive and detailed. By extending the conversation to include syntax coloring in mainstream IDEs, the book acknowledges the importance of developer tools in programming language adoption and efficiency. This holistic view encourages readers to consider not only the design and implementation of a language but also the ecosystem that supports it, including the tools that facilitate coding, debugging, and collaboration. Theoretical and Practical Synergy At its core, "Build Your Own Programming Language" bridges the theoretical foundations of programming language design with practical implementation strategies. Jeffery's meticulous coverage of topics from lexical analysis to garbage collection provides a roadmap for the entire development process. The dual presentation of concepts in Unicon and Java exemplifies the book's commitment to accessibility, offering readers insights into how different programming paradigms and languages can tackle similar problems. Mitigating the Software Crisis Jeffery's narrative is set against the backdrop of the ongoing software crisis, where the complexity of software development outstrips the capabilities of current programming languages. The book positions the creation of new, purpose-specific languages as a strategic countermeasure to this crisis. By empowering readers with the knowledge to design and implement these languages, Jeffery contributes to a potential alleviation of the software crisis, advocating for a future where software development is more intuitive, efficient, and tailored to specific needs. A Toolkit for Innovators The book serves as an indispensable toolkit for anyone interested in the art of programming language development. Its chapters cover a vast terrain, from the theoretical underpinnings of language design to the nuts and bolts of implementation, including intermediate code generation and runtime system considerations. This exhaustive coverage makes the book an essential resource for both practitioners looking to build new languages and academics seeking to enrich their curriculum with practical language implementation techniques. Bridging Academia and Industry "Build Your Own Programming Language" holds a unique position at the intersection of academic study and industry practice. Its practical emphasis complements theoretical coursework in computer science, particularly in compiler construction, by providing tangible examples and step-by-step guides to language development. This blend of theory and practice is crucial for preparing students for the complexities of real-world software development, bridging the gap between academic study and the demands of the software industry. Inspiring Future Innovations Jeffery's book is not just a manual; it's a source of inspiration for future innovations in programming language development. Detailing the process of building a programming language from scratch, it encourages readers to think creatively about how new languages can solve existing problems more effectively or address niche domains. The book lays the foundation for a new generation of programming languages that could redefine how we think about and interact with software, pushing the boundaries of what is possible in software development. A Call to Action "Build Your Own Programming Language" is a call to action for developers, students, and educators alike. It challenges readers to not only understand the mechanics of programming language development but to actively participate in the creation of new languages. Through this engagement, the book aims to foster a community of innovators who will drive the evolution of programming languages, ensuring that they evolve in step with the changing landscape of software development. Final Reflections In conclusion, Clinton Jeffery's second edition of "Build Your Own Programming Language" is a testament to the dynamic and collaborative nature of programming language development. Its comprehensive coverage, practical guidance, and responsive evolution reflect a deep understanding of both the challenges and opportunities in the field. By bridging theoretical concepts with practical implementation, Jeffery provides a roadmap for innovation in programming language design and implementation, contributing to the ongoing conversation about the future of programming and the role of developers in shaping that future. Through this work, Jeffery not only educates but also inspires a new generation of programmers and language designers to imagine and create the programming languages of tomorrow.
While the current Agile job crisis is apparent, there is also hope for practitioners willing to refine their skills, share knowledge, and network with peers. This article outlines actionable strategies for thriving in challenging times, emphasizing that growth and success are achievable by leveraging community strength and readily accessible resources. Check out also how I can support you on your journey below. What You Can Do To Improve Your Professional Standing To enhance your agility—no pun intended—and resilience in the face of the current Agile job crisis, I recommend engaging in a continuous learning and development journey, focusing on deepening your understanding of principles, sharing knowledge, and expanding your professional network through various practical activities: Deepen Your Understanding of Agile Principles Let us start with honing your craft to overcome the Agile job crisis: Regularly read and analyze the Agile Manifesto and Scrum Guide: Allocate time each week to reflect on one principle from the Agile Manifesto or a section of the Scrum Guide. Write down how you applied this principle or rule in your past projects and how you could do it differently. Engage in reflective practices: Start a personal journal to document your daily practices, noting successes, challenges, and lessons learned. Reflect on how your actions align with Agile values and principles. Experiment with applying principles: Initiate a “pet project” within your organization or community that allows you to apply Agile principles in a new context. Document the process and outcomes to share with others. Write articles or blog posts: Choose a specific principle each month and write an article or blog post on how it can be applied effectively. Share these writings on professional networks and solicit feedback. (Don’t be frustrated if your initial efforts do not cause a swell of responses; getting started and sticking with it is what matters.) Read books and listen to podcasts: Catch up with all the books you have ever wanted to read. And do not forget all podcasts on Agile. (I have a pile of unread or partially read books topping a meter in height myself.) Collaborate with other practitioners: Organize or join a monthly roundtable discussion with peers to exchange insights, experiences, and best practices. Use platforms like LinkedIn groups or Meetup to find or create such groups. (Check out my LinkedIn group, the Agile Clinic.) Mentor or coach others: Offer free coaching sessions to startups or non-profits. This offer will help refine your coaching skills while giving back to the community. Participate in advanced workshops or training sessions: Identify workshops that offer interactive, real-world problem-solving scenarios. Look for sessions that use role-play or simulation games to deepen your understanding of principles. Attend conferences or webinars: Choose events that offer case studies or insights into innovative applications of Agile principles. Prioritize interactive sessions where you can ask questions and engage directly with speakers. (See the Hands-on Agile Meetup community below.) Participate in community discussions: Join forums or social media groups. Regularly contribute to discussions, offering insights or asking thought-provoking questions. (For example, you may have noticed that I asked many questions in various LinkedIn groups to encourage reflection and discussions.) Diversify Your Skill Set To Overcome the Agile Job Crisis Next, sharpen your facilitation, coaching, and technical skills by staying adaptable: Develop strong facilitation skills: Practice by leading a volunteer group or a special interest club. Use these opportunities to experiment with new facilitation techniques, such as liberating structures, if you haven’t done so yet. Enhance coaching skills: Enroll in a course specifically for coaching skills development. Practice these skills in different contexts, including outside work, to refine them. Enhance communication skills: Join a local Toastmasters club or similar to practice public speaking and communication in a supportive environment. Acquire skills in (digital) tools: Choose a new tool each month to explore. Create tutorial videos or guides based on your learning and share them with the community. (There is an abundance of tools available for free. Moreover, I am not merely talking about software applications but also, for example, about canvases and other frameworks that augment “Agile.”) Study organizational change management: Apply for a short course or prepare for a challenging certification. Use volunteer opportunities to practice these skills in a real-world setting. (Coursera is a good place to start your search for a change management course.) Learn about various frameworks: Create a study group with peers interested in learning SAFe, Kanban, or other frameworks—set goals to apply one new framework aspect to a project every quarter. (You may not like SAFe; however, it is a prevailing player in large organizations. Deal with it.) Learn about emerging technologies: Join online courses or webinars focused on, for example, AI, blockchain, or IoT technologies. Explore how these can be integrated into Agile projects. (If you are not yet exploring Generative AI and its impact on your industry, you are losing out.) Build expertise in specific industries: Choose an industry and dive deep into its challenges and opportunities. Offer to give free webinars sharing Agile solutions to industry-specific problems. Understand budgeting and finance in an Agile context: Offer to assist with the budget planning session for a project, incorporating Agile principles into the financial planning process. Develop metrics and reporting techniques: Work on a personal project to explore different metrics in an agile context. Offer to prepare a metrics analysis report for a small team or project, providing insights and recommendations. Engaging With the Community Lastly, you never walk alone; reach out to your peers to overcome the current Agile job crisis collaboratively: Join Agile and Scrum user groups: Actively participate and offer to organize or speak at meetings. Meetup.com is a good starting point. Engage in online Agile communities: Share your experiences, ask questions, and support others posting inquiries. Set a goal to connect with a new practitioner each week, focusing on different industries or specializations. (You can quickly meet peers in LinkedIn, Subreddits, or Meetup groups.) Start a podcast or YouTube channel: Focus on sharing practical tips, interviewing other practitioners, and discussing the application of agile practices in various contexts. (Do not underestimate the grit required to do this, not to mention the technical aspects.) Participate in coaching or mentorship programs: As a mentor or mentee, engage deeply with the program to maximize learning and networking opportunities. Share and discuss case studies or success stories: Write up your own experiences or those of your network to share lessons learned and best practices. (Become known as someone who is supportive of the community; there is no better way of building a personal brand.) Actively contribute to blogs or social media groups: Regularly post insightful content, engage with others’ posts, and contribute to building a positive, knowledge-sharing community. (Algorithms love meaningful comment threads. LinkedIn, for example, ranks those threads at the top of all comments, which increases your visibility within the community massively.) Volunteer for conferences: Offer your skills in organizing, facilitating, or even speaking at events. Community-led Open Space or Barcamp events are often interested in volunteers. (The Agile Camp Berlin, for example, was built on volunteers’ help to organize and run the event.) Contribute to open-source projects: Find projects looking for practitioners to help guide their development process. Collaborate on research projects or papers: Contact academics or practitioners working on Agile research and offer your insights or collaboration. (Consider using ResearchGate for an initial analysis of who is working in the field.) How I Can Support You To Overcome the Agile Job Crisis There are several ways how I can tribute to you navigating the Agile job crisis; you do not have to start from scratch: Through my blog and ebooks, I can provide you with detailed insights and advanced strategies on Agile and Scrum, deepening your understanding and equipping you with innovative approaches to “Agile.” With my Scrum Anti-Patterns Guide book, I can enhance your grasp of Scrum, steering you away from common pitfalls and towards effective strategies to improve your Agile practices and outcomes. Join my Hands-on Agile Slack community. I’ll provide you with a valuable network where you can exchange ideas, gain diverse perspectives, and discover solutions to your Agile challenges, all of which will contribute to your professional growth. Don’t miss the opportunity to engage directly with your peers in my Hands-on Agile Meetup group, where I can connect you with thought leaders, real-world insights, and practical tips. Lastly, subscribe to my Food for Agile Thought newsletter for regular updates to keep you well-informed and a step ahead in your Agile journey. Conclusion Despite the challenging landscape, the path for Agile practitioners isn’t without hope. By dedicating time to hone your craft through accessible resources, sharing your insights generously, and engaging deeply with your peers, not as competitors but as vital allies in networking, you can navigate these turbulent times. This collaborative approach enriches your expertise and strengthens the Agile community, creating a win-win scenario for all involved. What are you already doing to educate yourself and support the Agile community? Please let us know your approach in the comments.
In the ever-evolving landscape of technology, becoming a professional coder is more than just mastering programming languages — it's a journey marked by dedication, perseverance, and a commitment to lifelong learning. While the path may seem daunting, aspiring coders can navigate it with confidence by embracing two fundamental principles: consistency and continuity. In this article, we'll explore how these pillars form the bedrock of a successful coding career and offer practical insights into incorporating them into your journey toward mastery. The Power of Consistency Consistency is the hallmark of excellence in any endeavor, and coding is no exception. It involves showing up day in and day out, honing your skills, and pushing the boundaries of your knowledge. Here's how consistency can propel you towards becoming a professional coder: 1. Establishing a Learning Routine Consistent learning is the key to staying relevant in the fast-paced world of technology. Set aside dedicated time each day or week to deepen your understanding of programming concepts, explore new technologies, and tackle coding challenges. Whether it's through online courses, coding exercises, or personal projects, make learning a non-negotiable part of your routine. 2. Practicing Deliberately Mere repetition is not enough to master coding; deliberate practice is essential. Focus on areas where you struggle, break down complex problems into manageable chunks, and seek feedback to identify areas for improvement. By consistently pushing yourself out of your comfort zone, you'll gradually build the expertise and confidence needed to tackle real-world coding projects. 3. Building a Portfolio Consistently working on projects and adding them to your portfolio demonstrates your skills and expertise to potential employers or clients. Whether it's contributing to open-source projects, building your own applications, or participating in coding competitions, showcase your work to highlight your proficiency and passion for coding. The Role of Continuity While consistency lays the foundation for success, continuity ensures that you stay on course and make steady progress towards your goals. It involves maintaining momentum, adapting to challenges, and embracing the iterative nature of learning to become a professional coder: 1. Embracing Lifelong Learning The tech industry is constantly evolving, with new languages, frameworks, and tools emerging at a rapid pace. Continuity requires a commitment to lifelong learning, where you stay curious, adapt to change, and embrace opportunities for growth. Whether it's attending conferences, participating in workshops, or joining coding communities, continue to expand your horizons and stay ahead of the curve. 2. Cultivating Resilience Coding is as much about troubleshooting and debugging as it is about writing code. Continuity involves persevering through setbacks, learning from failures, and staying resilient in the face of challenges. Embrace a growth mindset, view obstacles as opportunities for growth, and never lose sight of your long-term goals, even in the face of adversity. 3. Nurturing Relationships Success in coding often depends on collaboration and community support. Continuity involves nurturing relationships with fellow coders, mentors, and industry professionals, leveraging their expertise and insights to accelerate your learning journey. Engage in peer code reviews, participate in online forums, and seek mentorship to foster meaningful connections and expand your network. Bringing It All Together Becoming a professional coder is a journey that requires dedication, discipline, and a relentless pursuit of excellence. By embracing the principles of consistency and continuity, you can chart a course toward mastery, navigating the challenges and opportunities that lie ahead. Remember, Rome wasn't built in a day, and neither is a successful coding career. Stay consistent in your efforts, remain resilient in the face of setbacks, and embrace the journey with open arms. With patience, perseverance, and a passion for coding, the possibilities are limitless.
In today's rapidly evolving and highly competitive tech landscape, staying ahead of the curve is essential for career growth and success. As we look ahead to 2024, certain tech skills are poised to be in high demand, driving innovation and shaping the future of various industries. In this article, we'll explore the top 5 in-demand tech skills for 2024 and how they can propel your career forward, helping you stay relevant and get hired in the competitive job market. Artificial Intelligence and Machine Learning (AI/ML) Artificial intelligence (AI) and machine learning (ML) are revolutionizing industries ranging from healthcare to finance. Understanding key concepts like supervised learning, unsupervised learning, and reinforcement learning is crucial for harnessing the power of AI/ML. Moreover, proficiency in popular frameworks and libraries such as TensorFlow, PyTorch, and scikit-learn is highly sought after. Continuous learning in this dynamic field is essential to stay relevant and competitive. Check the learning resources at the end of this article to stay updated in the tech world. AI/ML skills are in high demand, with companies across industries looking for professionals who can develop innovative AI solutions to solve complex problems. Focus on Generative AI Solutions With the advancement of generative AI solutions, software engineers should focus on understanding and leveraging these technologies to drive innovation. This includes gaining familiarity with concepts like neural networks, deep learning, and generative adversarial networks (GANs). Hands-on experience with generative AI tools and frameworks such as TensorFlow, PyTorch, and OpenAI's GPT models is essential for developing practical skills in this area. Additionally, software engineers should explore specialization in specific applications of generative AI, such as natural language processing (NLP), computer vision, or creative content generation, to capitalize on emerging opportunities in the field. Cybersecurity With the increasing frequency and sophistication of cyber threats, cybersecurity has never been more important. Cybersecurity professionals play a vital role in protecting organizations from data breaches and ensuring the integrity of sensitive information. Roles such as cybersecurity analyst, penetration tester, and security architect are in high demand. Keeping abreast of the latest cybersecurity trends, including zero trust security and threat intelligence, is essential for safeguarding digital assets. Cybersecurity skills are highly valued by employers, and professionals with expertise in this area are in high demand as organizations prioritize security measures to protect their data and infrastructure. Cloud Computing Cloud computing continues to revolutionize the way organizations manage their IT infrastructures. Cloud platforms like AWS, Azure, and GCP offer scalability, flexibility, and cost-efficiency. Proficiency in cloud services and architectures is essential for building and maintaining modern cloud environments. Cloud certifications validate your skills and demonstrate your expertise to potential employers, making them a valuable asset in today's job market. Cloud computing skills are in high demand as companies migrate their operations to the cloud and seek professionals who can design, implement, and manage cloud-based solutions effectively. Several topics like this are discussed on my YouTube channel. Please visit. Appreciate your support. Data Science and Big Data Analytics Data has become the lifeblood of modern businesses, driving decision-making and innovation. Data science and big data analytics skills are in high demand across industries. From customer segmentation to predictive maintenance, the applications of data analytics are vast and varied. Tools like Tableau and Power BI are invaluable for visualizing data and communicating insights effectively. Developing expertise in data analysis and visualization is key to unlocking the full potential of data-driven decision-making. Data science and analytics skills are in high demand as companies seek professionals who can derive actionable insights from large and complex datasets to drive business growth and innovation. DevOps and Automation DevOps practices enable organizations to deliver software faster and more reliably through collaboration and automation. DevOps professionals play a crucial role in building and maintaining scalable and resilient systems. Tools like Jenkins, Ansible, Docker, and Kubernetes are widely used for automating software development and deployment processes. Embracing a culture of continuous improvement and cross-functional collaboration is essential for success in the world of DevOps. DevOps and automation skills are in high demand as companies adopt agile methodologies and seek professionals who can streamline software development processes and improve operational efficiency. In conclusion, acquiring and developing skills in the top 5 in-demand tech areas for 2024 is essential for career advancement and staying competitive in today's job market. Whether you're a seasoned professional or just starting your tech journey, investing in these skills will position you for success in the years to come. Keep learning, stay curious, and embrace the opportunities that technology has to offer. Must Reads for Continuous Learning System Design Head First Design Patterns Clean Code: A Handbook of Agile Software Craftsmanship Java Concurrency in Practice Java Performance: The Definitive Guide Designing Data-Intensive Applications Designing Distributed Systems Clean Architecture Kafka — The Definitive Guide Becoming An Effective Software Engineering Manager
I knew a Chief Software Architect from a major financial organization who was an anomaly: he had never developed software professionally. His undergraduate degree is in Accounting and Finance, and his most hands-on technology role was as a DBA. [His LinkedIn profile lists an early Programmer role, though he insisted he didn’t.] Even so, he was well-respected within his organization for his thought leadership and solutions, but nevertheless, it seemed an unusual career path. Since I last worked with him, he has moved into C-level roles at other organizations, confirming his abilities as a technology leader. Then I thought of others I have worked with who are non-technical but positioned to impact technical direction and realized their lack of understanding impacted (and continues to impact) the quality of the software solutions we, as engineers, are expected to deliver. Chief Non-Technical Officer This CTO has been with her/his company for many years in many roles: Director of Support, Chief Strategy Officer, Chief Cultural Officer, and Chief Technical Officer. S/he does not deny that s/he is not a strong technologist – and at times a badge of honor – yet confidently states decisions and direction that they become a fait accompli: alternatives that challenge her/his understanding are not often well received. At times, her/his inner circle helps to form a more nuanced understanding, but only to a point: overcoming her/his existing preconceived notions is difficult, and blatant opposition results in being sidelined from future discussions. By no means is s/he a total technical novice, but fundamental change requires extensive effort and time. Her/his oft-repeated mantra went something like this: Don’t tell me you’re refactoring; refactoring brings no value to our customers. Harking back to her/his strategy days, where feature-feature-feature is the overwhelming driver, this mantra confirmed her/his denial or lack of understanding of the current state of the product. The growing and maturing customer base made clear that areas of the product needed love and attention, but proposed efforts to address them were not prioritized because – in her/his view of the world – there was no visible benefit to their customers, at least when focused on customers asking for new or extended features. The real technologists of the company understood the potential benefits to both the customer and company: performance and scaling improvements, reduced cloud costs, faster deployments, fewer outages, faster feature delivery, reduced technology stack, and consistent and intuitive user experience. Regardless of potential benefits, nothing called out as refactoring would survive planning. The problems continued to grow, and the problems continued to be ignored. Sigh. Product To be clear, I have no interest in becoming a product owner: the wide-ranging responsibilities require a breadth of knowledge and experience not often found in a single person, while their many stakeholders – both internal and external – have contradictory goals and agendas that need to be balanced. I view it as a political role, finding compromises that please (appease) most, with no one getting everything s/he desired. This role is not for the weak and timid. Once we accept that product owners are unlikely to have the background or experiences necessary to handle all responsibilities, we can then understand why the focus is on those responsibilities understood or deemed important by their leaders. Outside of organizations offering technical solutions, product owners often have a stronger business understanding than technology understanding based on their work experience. Perhaps not surprisingly, the product is defined by business expectations more so than technical requirements: future features and functionality are defined by understanding industry trends, reviewing customer feedback, interpreting — sales and usage analytics, defining the user experience, etc. In essence, the product owner is an overclocked business analyst. Real-World Example A particular product manager focused only on rapidly releasing new features regardless of technical stability. Over time, the issues rose to the point where outages – not processing failures, actual outages – occurred daily and could no longer be ignored. She continued to view the work as unnecessary and not beneficial to the product, resulting in this exchange during quarterly planning: The result is product owners often eschew – whenever possible – technology and technical viability aspects of the product, reducing the impact of technology during product planning. Instead of top-down planning, individual engineers attempt to push technical issues bottom-up, which is very difficult and often unsuccessful. Organizations require a strong engineering discipline and culture to offset the business focus of product owners, but it remains a frustrating challenge. [Of course, production technology issues do arise that demand immediate attention, but the resulting work is stressful, particularly for the engineers who are responsible for implementing the changes required; the result is often a one-off effort rather than fundamentally changing the overall culture.] The Not-Ready-For-Prime-Time Implementation This is less about an individual or role but rather an organizational culture problem: proof-of-concepts assumed to be production-ready. Software proofs-of-concept (POCs) are created to test new business concepts or determine the usefulness or applicability of new technology. POCs should be created with minimal engineering rigor that allows a quick and cheap implementation to be discarded without guilt once the results are evaluated. Most important, it is not intended to be a workable product. Despite these clear expectations, too often, I’ve seen the business get excited at seeing the POC and want it available to customers immediately. The POC might be slightly enhanced or it might be unaltered, but it’s out there for the world (internal or external) to use. And when the problems start appearing – because, by definition, it was not intended for real-world usage – the finger-pointing begins. Agile advocates snigger and say You needed an MVP, silly! but my experiences are much the same as POCs: poor. By definition, an MVP is a complete application without the bells and whistles, but corners are inevitably cut: crawling (of crawl/walk/run paradigm) when current volumes require walk, run, or even fly; minimal/non-existent observability; non-standard user experience; incomplete or incorrect API definitions; security through obscurity; incomplete error handling. When leaders decide to move forward after a successful MVP, the expectation is to expand and enhance the MVP implementation; in fact, it may be better to start over. [I am not disavowing MVPs’ usefulness but rather am clarifying that organizations misuse/abuse the term and are, in fact, creating glorified POCs that are not complete, are not ready for users, and are not production ready. Just saying…] So when you next hear of an access application that is integrated into the enterprise supply chain workflow, don’t say I didn’t warn you. Organizations who make ignorant decisions on the production-readiness of applications shouldn’t know why failures occur later, yet they do, and the engineers are left to pick up the pieces. What Can You Do? It’s not hopeless, really. It isn’t …. not necessarily fun, but there are strategies that you can attempt. Gather Create a personal archive of articles, use cases, scenarios, and data that allows you to tell stories to non-technical people, helping them understand the tradeoffs present in all organizations. Internally, you might be interested in estimated vs. actual effort for feature delivery, production failure rates, or implementation costs mapped to the customer base. Are cloud costs increasing faster than customer growth? Did assumptions made during initial implementation impact the ability to deploy future features, whether positive or negative? Is supposedly important work upended by unknown and unplanned initiatives? Did a potential security breach impact customer confidence? What was the cost of researching a potential security breach? Is data quality affecting your reporting, analytics, and billing? There are many different ways to try and understand what’s happening within your organization. Almost daily, there are new articles online that highlight the issues and problems other organizations experience: Southwest’s 2022 holiday meltdown, a ransomware attack on Vital Care Providers, and Cloudfare’s bad software deployment. Not every organization publishes postmortems, but details often leak through other channels. Perhaps more importantly, your organization doesn’t want to appear in those articles! Educate As most non-technical folks appear unable or unwilling to accept that software is hard, our responsibility – for better or worse – is to show and explain. Unique situations require adjusting the story told, but it is necessary – and never-ending – to have any chance to get the organization to understand: explaining how software is developed and deployed, demonstrating how a data-driven organization requires quality data to make correct decisions, explaining the advantages and disadvantages of leveraging open source solutions; showing examples of how open source licenses impact your organization’s intellectual property. Look for opportunities to inject background and substance when appropriate, as education is open-ended and never-ending. Often, it will appear no one is listening as you repeat yourself, but eventually – hopefully – someone will parrot what you’ve been saying for months. Negotiate Aside from those employed in purely research and development roles, engineering/technology for engineering/technology's sake is not feasible, as technology concerns must be balanced with business concerns: product and its competitors, sales pipeline, customer support and feature requests, security, privacy, compliance, etc. Each decision has its short- and long-term impacts, and it is very unlikely that all involved will be pleased. Sorry, but that’s corporate politics. That does not mean you roll over and play dead, but rather horse trade, often with management and product, to ensure the technical concerns aren’t forgotten: Ensure that changes in business priorities are coupled with impact analysis on in-process development efforts; Accept less-than-optimal initial implementations with the agreement of fast-follow work to address compromises; Define metrics that identify when technology-focused work should be prioritized over feature work. These ideas may or may not apply to your organization or situation, but hopefully, they will give you ideas that may be pursued. Conclusion The problems I’ve discussed are age-old and have seemed to become worse in recent decades, so I’m not sure if any of what I’ve discussed is a surprise. Perhaps this is only the latest incarnation of the problem and post-Agile a new approach will reap benefits. Perhaps leaders will acknowledge that engineers really do understand the problems and are trusted to implement a solution rather than given solutions that fit an arbitrary (and often unrealistic) timeline. It’s a tug-of-war that I don’t yet see resolved. Image Credits “Pointy Hair Boss” © Scott Adams “Productivity: Putting the Kanban Display Together” by orcmid is licensed under CC BY 2.0. “Analog circuit board prototype” by mightyohm is licensed under CC BY-SA 2.0.
Miguel Garcia
VP of Engineering,
Nextail Labs
Jade Rubick
Engineering advisor,
Jade Rubick Consulting LLC
Manas Dash
Software Development Engineer,
TESCO
Scott Sosna
Senior Software Engineer II,
Datasite