In this article, we will explore what developer relations is, the purpose it serves, and why it is vital for the success of both developers and companies.

What is Developer Relations?

In simple terms, developer relations (DevRel) is a set of activities and practices aimed at building and maintaining relationships between developers and companies. These activities may include organizing hackathons, creating open-source projects, offering developer-focused content and resources, and more.

The ultimate goal of DevRel is to help developers be successful using a company's products and services, while also providing valuable feedback to the company about how to improve those products and services.

The History of Developer Relations

While developer relations may seem like a modern concept, it has been around since the early days of computing. One of the earliest examples of DevRel is the IBM Developer Network, which was established in the 1980s to support developers working with IBM products. Since then, many other companies, from startups to large corporations, have established their own DevRel programs.

The Purpose of Developer Relations

The purpose of developer relations is twofold: to help developers be successful and to help companies improve their products and services. Developers are the heart and soul of the tech industry, and their success is essential to the success of any company that creates software or technology.

By providing developers with the resources, support, and community they need, companies can help ensure that their products are used and loved by developers around the world.

At the same time, DevRel also helps companies improve their products and services. By engaging with developers and listening to their feedback, companies can learn how to make their products better and more useful for their customers.

DevRel also helps companies build trust and credibility with developers, which can be critical in an industry where word-of-mouth recommendations and referrals are so important.

Why Developer Relations is Vital for Success

Developer relations is vital for the success of both developers and companies. For developers, DevRel provides access to valuable resources, including documentation, sample code, tutorials, and more. DevRel also helps developers build relationships with other developers, which can lead to collaboration, mentoring, and other opportunities.

For companies, DevRel is essential for building and maintaining relationships with developers, who are often the primary users of their products and services. DevRel also helps companies gain valuable feedback about their products and services, which can help them improve those products and better serve their customers.

Keep Going

Developer Relations is a critical component of the tech industry, with a long history and a bright future. By providing developers with the resources, support, and community they need, companies can help ensure the success of both developers and their own products and services.

As developers, we should be grateful for the efforts of DevRel teams around the world, and as companies, we should continue to invest in these programs to ensure the success of our industry as a whole.

Artificial Intelligence (AI) has been making significant strides in a variety of fields, and one area where it's having a profound impact is in fostering developer communities. As the digital landscape becomes more complex and competitive, engaging developer communities has become crucial for businesses. AI-driven platforms and tools are playing a pivotal role in strengthening these communities by analyzing developer behavior, providing targeted content, and promoting inclusivity.

Personalized Experiences for Developers

One of the most significant ways AI-driven platforms enhance community engagement is by offering personalized experiences for developers. By analyzing individual preferences, needs, and behavior, these platforms can deliver tailored content and recommendations, creating a more satisfying and relevant experience for developers.

Something like Coveo can create content recommendations based on several algorithms like previously viewed together items - which can make flows for documentation tailored to the reader based on previous data.

This personalization not only makes developers feel valued and understood but also helps them work more efficiently and effectively. It fosters a sense of belonging within the community, ultimately leading to stronger connections and loyalty.

AI-powered Community Analytics

Understanding the needs and preferences of a developer community is essential for businesses to engage effectively. AI-driven platforms can analyze vast amounts of data to identify trends, patterns, and insights that can help businesses better understand and serve their developer communities.

Armed with this valuable information, businesses can tailor their content, resources, and support to better meet the needs of their developers. This data-driven approach fosters a deeper level of engagement and loyalty within the community.

While there are several data analytics tools out there, a community-specific one is still yet to emerge that I have found. Let me know if you have one in the comments.

Inclusive and Accessible Communities

Inclusivity and accessibility are essential elements of a thriving developer community. AI-driven platforms can help create more inclusive spaces by identifying and addressing potential barriers to participation. For instance, AI-powered language translation tools can bridge language barriers, enabling developers from diverse backgrounds to communicate and collaborate seamlessly.

By fostering inclusive and accessible communities, businesses can tap into the collective knowledge and skills of a diverse developer base, driving innovation and growth. Here is a list of various translation tools you can check out!

Enhanced Collaboration and Communication

Strong communication is the backbone of any successful developer community. AI-driven platforms can facilitate more effective communication by providing intelligent suggestions, automating repetitive tasks, and streamlining collaboration.

These platforms enable developers to work together more efficiently, share knowledge, and solve problems collectively. As a result, the community becomes more cohesive and collaborative, driving greater success for both developers and businesses.

If you have any recommendations for your favorites - please add them in the comments. I don't personally have any recommendations here.

Embracing AI-driven Community Engagement

The impact of AI-driven community engagement is undeniable. As businesses continue to integrate AI into their developer relations strategies, they can expect to see stronger, more connected, and more engaged developer communities. By leveraging the power of AI, businesses can create a thriving ecosystem that fosters innovation, collaboration, and success.

How are you currently using AI in your community? I would love to hear from you in the comments.

A Game Changer

As the technology landscape grows more complex and competitive, the need for effective developer relations has never been more critical. With AI, we're witnessing a revolution in how companies can now engage with developers.

By leveraging machine learning and natural language processing, AI-powered tools can automate tasks, personalize developer experiences, and revolutionize how businesses and developers communicate.

These tools save time and effort and help build trust and rapport between businesses and developers. The result? Better collaboration, increased productivity, and a stronger sense of community.

Streamlining Tasks

One of the most significant impacts of AI on developer relations is the automation of routine tasks. With AI-driven tools, manual processes such as documentation generation, issue tracking, and code review can be streamlined, freeing up time for developer advocates to focus on more strategic efforts.

Similarly, AI-powered chatbots are revolutionizing customer support by providing quick and accurate responses to developers' queries, helping to reduce response times, and ensuring developers receive the support they need.

Enhancing Communication and Collaboration

AI is also helping to bridge the communication gap between developers and businesses. By analyzing developer behavior, AI platforms can provide personalized recommendations and facilitate more effective communication.

By understanding individual preferences and needs, these tools can foster more inclusive and engaging experiences for developers, ultimately creating a stronger sense of community and belonging.

AI can also analyze data to identify trends and patterns, providing businesses with valuable insights into the needs and preferences of their developer communities. This information can be used to tailor content, resources, and support to serve developers better, fostering a deeper level of engagement and loyalty.

A Seamless Developer Experience

With the rise of AI, we're also seeing a push toward more personalized developer experiences. By leveraging machine learning algorithms, AI-driven tools can analyze developer behavior to create customized learning paths, recommend resources, and even predict potential issues before they arise.

This level of personalization not only helps developers feel more valued and understood, but also enables them to work more efficiently and effectively.

Embracing AI in Developer Relations

As AI continues to make its presence known, we can expect to see even more innovative tools and platforms that push the boundaries of what's possible. By embracing these new technologies, businesses can foster stronger relationships with their developer communities, streamline their operations, and ultimately drive greater adoption of their products and services.

The Competitive Edge

As the competition for developers' attention intensifies, businesses must stay ahead of the curve to remain relevant. By leveraging AI-driven tools, companies can provide developers with exceptional experiences and resources, setting themselves apart from the competition.

Preparing for the Future

Businesses need to stay informed and adapt to the changes that AI brings with it. By understanding the benefits and potential challenges of AI-driven tools, companies can make informed decisions and better position themselves for success.

Here are a few strategies to consider when integrating AI into your developer relations program:

1. Invest in AI-driven tools and platforms: Explore the latest AI-powered tools to streamline tasks, improve communication, and personalize developer experiences. Stay informed about emerging technologies and consider incorporating them into your developer relations strategy.

2. Focus on building trust: Transparency is vital when it comes to AI. Be open about using AI tools and ensure developers understand the benefits these tools can provide. Address any concerns and be proactive in demonstrating these technologies' value and ethical considerations.

3. Adapt to developers' changing needs: As AI changes the landscape of developer relations, developers' needs and expectations will also evolve. Stay attuned to these changes, and be prepared to adjust your developer relations strategy accordingly.

4. Foster a culture of innovation: Encourage your developer relations team to stay informed about AI and its potential applications. Provide opportunities for learning and experimentation, and create an environment where innovation can thrive.

By embracing AI and its potential in developer relations, businesses can create stronger bonds with their developer communities, drive increased adoption of their products and services, and remain competitive in an ever-changing landscape.

Conclusion

AI will undoubtedly become the new face of developer relations, transforming how businesses engage with developers and streamlining tasks that were once time-consuming and labor-intensive.

As AI-driven tools continue to revolutionize this space, businesses must adapt to stay ahead of the curve and provide the best possible experiences for their developer communities. By embracing AI and its opportunities, companies can foster deeper connections with their developers, ultimately driving higher success for all parties involved.

As we move forward, the integration of AI in developer relations will only continue to grow, shaping the future of how businesses and developers collaborate and communicate.

When I worked at ExactTarget, the Journey Builder application was first released to the public. This opened my eyes to the world of customer-centric marketing and how thinking about the users from their perspective can have an incredible impact. It taught me to see things as a journey and has translated into many aspects of my career.

The Developer Journey

The developer journey is a complex and dynamic process comprising several vital stages: onboarding, technical support, and community building. To ensure a positive developer experience, companies must focus on enhancing the onboarding process, providing timely and effective technical support, and fostering a strong community of developers.

Onboarding

Onboarding is the first stage of the developer journey and sets the tone for the rest of the experience. This is where developers learn about a product and get up to speed on how to use it. To ensure a positive onboarding experience, companies must provide clear, concise documentation, resources, and accessible technical support. A positive onboarding experience can build a positive relationship with developers from the start and impact their view of a product.

Technical Support

Technical support is a critical touchpoint in the developer journey. Developers may encounter challenges or need additional help along the way. Having a team available to answer questions and provide guidance can significantly impact the developer experience. Timely and effective technical support that resolves issues quickly and efficiently is essential to ensuring a positive developer experience.

Community Building

Community building is an essential element of the developer journey. A vibrant and supportive community can attract new developers to a product and keep existing users engaged and invested. Building a solid community can lead to more effective and efficient problem-solving, increased innovation, and improved developer satisfaction. Companies can foster a sense of community among developers by hosting meetups, creating forums for discussion, and encouraging collaboration and feedback.

Why is the Developer Experience Important?

When developers are the ones who use a product, their experience directly impacts their decision to continue using it or recommend it to others. By enhancing the developer experience, companies can build stronger relationships with this influential audience and increase their likelihood of continuing to use a product.

The developer experience extends beyond just the technical items of a product. It also encompasses how developers are supported and valued and about creating a culture that prioritizes their needs and feedback. A holistic approach to the developer experience can ensure that companies provide the support and resources developers need to succeed.

Empathy and Communication

Empathy and communication are two critical components of a positive developer experience. Companies can create a more supportive environment that fosters innovation and collaboration by putting themselves in developers' shoes and understanding their needs and challenges. Clear and concise documentation, prompt technical support responses, and active engagement with the developer community are all important facets of good communication.

The Role of Developer Relations

Developer Relations' core purpose is to foster strong relationships with developers and understand their needs and challenges. By working closely with developers and supporting them through every stage of their journey, companies can create a positive and seamless experience that leaves a lasting impression.

Conclusion

Companies prioritizing the developer experience will benefit from increased retention, a strong community, and improved relationships with this influential audience. Companies can create a supportive environment that fosters innovation and collaboration by taking a holistic approach to the developer experience and focusing on empathy, communication, and community building.

In this post, we'll discuss the good, bad, and ugly of inexperienced leadership in DevRel. We'll cover how new leaders can bring fresh ideas to the table, the problems they might run into, and the consequences of bad leadership. The bottom line is inexperienced leadership in DevRel can be a real problem. But if you're aware of the risks and have a plan, you can avoid disaster.

The Good

Okay, so there are some upsides to having inexperienced leaders in DevRel. One of the biggest is that they can bring fresh ideas to the table. They may have a different level of industry knowledge than more experienced leaders, but they can still come up with new solutions to problems.

Another plus is that new leaders can help make the DevRel team more diverse. A mix of experienced and inexperienced leaders can bring a balance of perspectives and lead to a more inclusive and innovative environment. And, if the DevRel team is more diverse, they'll likely be able to understand and serve a diverse group of developers.

In addition, new leaders can bring a lot of energy and enthusiasm to the DevRel team. They may be more willing to take risks and try new things, which can benefit the team and the company.

Generally, inexperienced leaders will face challenges but can also bring value to the DevRel team and the company. And remember, everyone has to start somewhere. With the proper training and support, inexperienced leaders can become influential leaders.

The Bad

While inexperienced leadership in DevRel can have some positive benefits, it can lead to several challenges and obstacles. One of the biggest challenges that inexperienced leaders may face is a need for more industry knowledge and experience. This can make it difficult for them to navigate the complex and ever-changing world of developer relations. They may need to be better familiar with industry best practices to understand the community's needs and pain points.

The need for more communication skills is another challenge. Inexperienced leaders may need to communicate more effectively with the developer community or the rest of the team. Having the proper voice with the developer community is essential - being authentic is vital. Lacking the communication skills to be authentic can ultimately result in poor outcomes for the company.

Along with these challenges, inexperienced leaders may need more technical skills to communicate and promote the company's products and services to developers. This can make it difficult for the DevRel team to effectively promote the company's products and services to developers, resulting in poor product adoption and a loss of revenue for the company.

Inexperienced leadership in DevRel can lead to many challenges and obstacles. It's essential to be aware of these potential pitfalls and have a plan to mitigate them. This may include providing additional training, support, and mentorship to inexperienced leaders to help them overcome these challenges and become influential leaders in the future.

The Ugly

The consequences of inexperienced leadership in DevRel can be severe, leading to some adverse outcomes for the developer community and the company. One of the most significant issues that can arise is a loss of developer trust.

Developers rely on the DevRel team to provide accurate and reliable information about the company's products and services. If the leader is equipped to handle their role, they may give inaccurate or misleading information, which can erode trust and lead to a loss of developers.

Poor product adoption is another potential outcome of inadequate leadership. If the DevRel team is responsible for product evangelism, then developers are an important target market for the company. If the leader can authentically communicate the value of the products and services, it may lead to better adoption and ultimately result in a loss of revenue for the company.

Leadership can also lead to a lack of alignment within the DevRel team and the broader company. If the leader can't effectively communicate the company's goals and objectives, it can lead to a lack of clarity and direction within the team. This can lead to a lack of productivity and ultimately result in a poor outcome for the company.

Moreover, inexperienced leadership can lead to a lack of motivation, burnout, and a high turnover rate among the team members, further deteriorating the team's overall performance.

It is crucial to have a solid leadership team in place to ensure the success of the DevRel program. Poor leadership can disastrously impact the developer community and the company. It's crucial to have a good leadership training and support program in place to ensure that inexperienced leaders are equipped to handle their roles effectively.

Conclusion

DevRel is an essential aspect of the tech industry, and it's vital to have a good relationship with developers. However, inexperienced leadership in DevRel can lead to several challenges and negative consequences. It's helpful to be mindful of these issues and prepare yourself for them ahead of time.

While inexperienced leaders can bring fresh ideas, diversity, and energy to the DevRel team, they may also need more industry knowledge, communication, and technical skills. This can lead to poor product adoption, lack of alignment within the team, and loss of trust from the developer community.

To ensure the DevRel program's success, a solid leadership team must be in place. With proper experience, training, and support, inexperienced leaders can become influential leaders and avoid disastrous results.

From technical evangelism to community management, developer relations professionals wear many hats. They act as the voice of the developer community inside the company, providing valuable feedback and insights to help shape product development. They also serve as the company's voice in the developer community, sharing updates, resources, and best practices.

So, whether you're just starting in developer relations or a seasoned pro, this post will give you a better understanding of the field and help you navigate the many roles and responsibilities of a developer relations professional. Let's dive in!

Skills

When it comes to excelling in developer relations, there are a few essential and critical skills. The first is strong communication skills. As a developer relations professional, you will interact with developers from all backgrounds, colleagues, and stakeholders from other teams. Communicating effectively verbally and in writing is crucial to building trust and establishing solid relationships.

Another essential skill is technical acumen. While you don't need to be a software developer yourself (although it does help a bit), having a solid understanding of the technical side of things is critical to understand developers' needs and concerns and effectively advocating for them within the company. This can be achieved through experience working in a technical role or ongoing learning and education.

In addition to these skills, building relationships and advocating for developers are also vital. Developer relations foster a sense of community and connection between a company and its developer base. Building relationships with developers, understanding their needs and concerns, and advocating for them within the company are critical to the success of a developer relations professional.

Finally, empathizing with developers and understanding their perspectives is crucial to building trust and establishing effective relationships. This skill is often developed through experience and continuous learning of the developer ecosystem and its trends.

Roles

The role of a developer relations professional can vary depending on the company and the specific needs of the developer community. However, a few key responsibilities are shared across the field.

One of the primary roles of a developer relations professional is to act as the voice of the developer community within the company. This means gathering feedback and insights from developers and then sharing that information with other teams, such as product development, marketing, and customer support. This helps ensure that the needs and concerns of the developer community are taken into account when making decisions about products and services.

Another critical responsibility of a developer relations professional is to act as the company's voice within the developer community. This means sharing updates and resources with developers, answering questions, and addressing concerns. This helps build trust and strong relationships with the developer community, which can lead to increased adoption of products and services.

A developer relations professional also often plays a crucial role in community management. This includes organizing and hosting events, such as meetups and hackathons, and creating and maintaining online communities, such as forums and social media groups. Community management helps to foster a sense of community and connection among developers and can also be a great way to gather feedback and insights.

Finally, a developer relations professional also serves as the company's technical evangelist. This means promoting and showcasing the company's products and services to developers and providing technical support and resources. Technical evangelism helps to increase awareness and adoption of the company's products and services among the developer community.

Advice

Transitioning into a developer relations role can seem daunting, but it can be a rewarding and fulfilling career path with the right mindset and approach. Here are some tips and advice on how to make the transition.

Networking is one of the most important things you can do when transitioning into a developer relations role. Attend conferences and meetups, join online communities and groups, and connect with other developer relations professionals. Not only will you learn from others in the field, but you'll also have the opportunity to make connections that can lead to job opportunities.

Gaining relevant experience is also crucial when making the transition. Participating in open-source projects, working in a technical role, or volunteering at developer events can help to build your skills and knowledge. It also allows you to showcase your experience and skills to potential employers.

Building a personal brand can also be beneficial when making the transition. Creating a portfolio of your work, writing blog posts or articles, and sharing your knowledge and experience on social media help establish you as a thought leader. This can attract potential employers and showcase your skills and experience.

It's also important to stay current with the latest trends and best practices in the field and to continuously learn and grow your skills. Reading industry publications, following influential people in the area, and taking online courses are great ways to stay up-to-date and continue developing your skills.

Finally, don't be afraid to take risks and try new things. Developer relations is a field that is constantly evolving, and those who are willing to adapt and try new things are often the most successful. Keep an open mind, be ready to learn and grow, and don't hesitate to step out of your comfort zone.

Conclusion

In conclusion, developer relations is a dynamic and critical field in the tech industry. It is vital in building and maintaining relationships between a company and its developer community. It is essential for the success of any organization that creates and distributes technology.

By understanding a developer relations professional's various roles and responsibilities and the critical skills needed to excel in this field, you can transition into a developer relations role and help bridge the gap between companies and the developer community. We hope this post has provided you with valuable insights and resources to help you pursue a career in developer relations and make an impact in the tech industry.

Remember to stay current with the latest trends and best practices in the field, continuously learn and grow your skills, and don't be afraid to take risks and try new things. Keep building connections and relationships, and always be open to new opportunities to improve your developer relations skills.

I honestly don't know how to answer the question because, even to me, it still is a mystery. This post will collect my thoughts and hopefully provide some answers to those curious.

The Who

I remember during my senior year of high school when I realized I had put on so much weight that my clothes no longer fit me, and I needed to buy larger sizes. What I didn't know at that time was that it would be a 25-year battle of self-image, self-loathing, and motivation.

Over that time, I've tried just about everything to lose weight: Atkins, South Beach, Juice cleanses, Weight Watchers, Mediterranean, Cabbage, Paleo, Keto, Low Carb, Body For Life, Low Sugar, Calorie counting, Weight lifting, Cardio, Aerobics, Running, etc.

Sometimes I took those efforts seriously, getting down to 280 pounds twice. 280 does not seem like a good number for a 5'11" male who is supposed to weigh under 190 lbs, but when you previously clocked in at 400 lbs or more, it feels incredible. However, I would always gain the weight back.

I learned that diets are not sustainable and surgery doesn't work for everyone. More importantly, I started to understand that programs are designed to make you temporarily lose weight, are unsustainable, or worse for your health than you think.

You would think that being diagnosed with Type 2 Diabetes would have pushed me to get things under control, but I had convinced myself that no matter what I weighed, I was healthy or that even thin people get sick. I became an expert at evading my efforts.

Anything can be okay in moderation, but not when dieting is so far off course that even moderation is excess. I would eat plateful after plateful, never feeling full or satisfied. I would wake up hungry, despite eating 2500 calories for dinner the night before. I was sick but had convinced myself that I was healthy and that my body was naturally heavy and needed the extra weight.

The Why

Before I get to how I lost weight, I want to talk about my love of amusement parks and roller coasters. Around 13, our school went on a field trip to Cedar Point. It wasn't my first time at an amusement park, but this time I finally talked myself into riding a coaster with loops, and after that, I was hooked. Every summer, I would get to a park and ride as many roller coasters as I could. The atmosphere, the heat, the lines, all of it, I loved it.

However, most rides don't cater to larger bodies. I recall countless times feeling dejected after waiting in line for a ride I couldn't fit in. I had to watch my kids enjoy riding coasters from the sidelines. Ultimately, this reality sinking in and watching my wife lose weight the year before finally pushed me towards action.

The How

Most people wish this were where I could say, "I did X," and that was it - end of the post. Typically, my answer to those who ask is, "I ate less." This answer never feels good enough or can even be condescending and rude. So let me try and explain what that means exactly.

Eat Less

I used to love eating at Wendy's. I would order a double (mayo and cheese only), large fries, and a large diet drink (saving calories, of course). Besides the two days' worth of caloric intake in a sitting, the number of addictive chemicals in that meal made me only want it more.

The most important lesson was how addictive food could be. I used to think ice cream and pizza were "bad foods" or salads and veggies were "good." Both things are the same - food. The ingredients make all the difference.

Two brands of peanut butter, with 200 calories/serving, can have completely different ingredients, depending on the amount of sugar and oils added. Removing processed foods from my diet didn't all happen at once. I backed down slowly. I think this is critical - quitting anything this addictive without stepping down is dangerous and fruitless. It tends to lead to severe levels of bounce back.

A triple became a single, and fries became small. I could get the taste without as many calories. Over time, I wanted it less and less. The foods many of us eat, especially diet foods, contain so much stuff that our bodies don't know what to do with them.

The more I eliminated fast foods - frozen meals, dining out, prepackaged foods - the more I lost. Do I still eat junk? Yep. Just so much less often and on a significantly lower amount.

Eat Less Often

I found myself eating around the same time every day, regardless. The first habit I had to break was eating on a schedule, not when I was hungry. This behavior would lead me to eat 4000+ calories daily without thinking. I honestly didn't even know what hunger was anymore.

Searching for what hunger felt like took some time, but I'm not sure how long. It took paying close attention to my body and waiting to eat only when I truly felt hungry. Asking the simple question, "am I hungry" I typically answer no.

Eventually, I could turn this new understanding into a more rigorous fasting approach. I am now able to fast and control intake without the initial struggles.

Measuring Success

My initial measurement of success was stepping on a scale 2-3 times a day. Any loss was a win and felt great. Setting weight goals helped - my first was to get under 300 lbs. After that, I used 20-pound increments to not overwhelm myself with taking on too big of a goal.

Recording my weight was a big eye-opener. There was a pattern of loss/gain that I had never noticed before — seeing the pattern and associating that with how I was eating and feeling at the time helped my brain comprehend what was happening. It was something I could repeat now, with consistent results.

I also used roller coasters at a nearby theme park that year as a measurement - starting the season only fitting on a few to ending the year by riding them all. Clothing sizes also became a gauge. Going from 3XL to L and a 56" waist to 36" was a clear indicator that things were working.

Final Thoughts

While it may seem like a brush-off type of answer, "I eat less food" is the only way I can sum up a year of retraining my mind and body to understand how to feed itself again. The problem with asking me how is I am still in disbelief myself and do not believe I have any level of expertise that will ultimately help.

What I can say is - you will have a different journey. You will find the patterns, habits, and foods that work best for you. If I have learned anything, it is this - no one else will do the work for you. No diet, book, video, class, or anything else will change you. It was not easy, but the extra time I may have with my family makes it worth it.

Looking back on last year, there's no denying it was great. In April, I joined Zoom. I love being a part of such a fantastic team. I also had the opportunity to watch my son learn the vibraphone and play with the high school marching band, which was a fantastic experience. The family even took a trip to Universal Studios, which was so much fun.

But perhaps the year's highlight was my first professional magic performance. I've always been interested in magic and have been practicing for years, but finally, being able to perform for a paying audience was a dream come true. It was a little nerve-wracking at first, but the reactions I got from the crowd made it all worth it.

In addition to that, I was fortunate enough to be invited to speak at two conferences last year. It was an excellent opportunity to share my knowledge and experiences with others, and I hope to have the chance to do more of that in the future.

As great as 2022 was, though, it went by fast, and now we are at the start of 2023. But I'm excited about all that this year has in store.

At Zoom, we've got some inspiring initiatives that will significantly impact developers' lives. I'm also working on a small project that has the potential to turn into something huge in the long term.

And on a personal level, my wife and I are planning a trip to Vegas, which we've wanted to do for a long time, and then later in the year to see Metallica. Who knows what other adventures and opportunities the year will bring?

One thing I'm committed to this year is producing more content. I've always enjoyed blogging and streaming, and I look forward to doing more in 2023. I'm also hoping to have the chance to give more talks and possibly even host some workshops.

Overall, I'm feeling pretty optimistic about the year ahead. Here's to an incredible 2023!

Firebase

One of the more forward-looking platforms used during my tenure was Firebase. I was able to spend a ton of time here learning how to use as much of the functionality that Firebase had to offer. Whether it was SMS translation, or adding two-factor authentication, the tool kit that Firebase gives you is extremely powerful, and always a consideration when I create new projects.

Sentiment Analysis

While easy to implement, Sentiment analysis is hard to get right and is far from perfect. However, as a general guide for intervention, it can do a good job of finding customers that may be more upset and can make that actionable. For call centers, it's a great tool.

Read my comparison - although it's a bit dusty now

Chatbots

Chatbots can be super fun, or really frustrating. While they can provide easy solutions to simple problems, covering all cases can be tricky, and it's easy to miss flows. Couple that with also trying to use speech transcription to match nouns and verbs programmatically, and now it's a disaster.

With the right amount of effort and planning, however, they can be extremely powerful and handle quite a lot of typical use cases. You can always push the call to a human when the script isn't working as a last resort.

You can read the tutorial for that here.

Transcription

I feel like transcription is really well solved in most cases. Listening to audio and transcribing it word for word is the main function of these APIs, and they all do it efficiently and accurately. Don't be afraid to use them.

[Read another outdated comparison] (https://developer.vonage.com/blog/19/09/10/extending-nexmo-streaming-transcription-dr)

Translation

Translation, much like transcription, has been fairly well solved. Every translation API has some kind of lexicon customization to cover industry-specific terms and can cost a lot more than the base service, however, the basic level of translation is really good in general. I plan on using these more in the future as well.

One more ancient review

XState

One of my favorite tools in JavaScript these days is XState. The ability to define how an application should work as a state machine, and use that in any front or back end to control the flow of states - chef's kiss. I found it extremely useful with things like video, as I could create states that matched exactly what was happening with the SDK and API.

It's really a lot of fun to use - I recommend you try it out.

Oclif and CLI Design

I built the Vonage CLI using Oclif, and I've really learned to love using oclif, CLI best practices, CLI history, and the command line itself.

Building a CLI isn't always the easiest thing to do, as it can run in so many environments, but solving these types of problems are fun for me.

Lerna/Monrepo

While building the CLI and an updated SDK, I decided to work in a monorepo structure, using Lerna to manage the publication of the modules. I plan on writing more on how that is used in the future as well. It's a great resource, easy to understand, but hard to get started.

Typescript (sorta)

Last, and well, least, Typescript. I have an appreciation for types now, and while I still feel like I have a long way to go, learning Typescript has been rewarding, if not frustrating. This was one of the harder things to learn for me, but I really am better off for doing it.

Conclusion

Overall - it was a great learning experience. Being able to learn new things as a developer advocate is one of my favorite aspects of the job.

I'm thankful for the opportunities I've had here, and look forward to the future.

The concept of state machines and state charts is not new, and it isn't rooted in front-end development, either. It's a mathematical model, and one used in many things around us. As an example, a light can be OFF or ON. You can describe anything with a state machine, even though this is a simple example.

Introduction to XState

Using a state machine in front-end development has become much less complicated with the creation of the package XState. XState helps us define state machines, create events and effects, and control the entire application flow. XState uses JavaScript methods and objects to describe the state machine.

The light bulb example from above would be written out like the following:

const lightBulb = Machine({
  id: 'lightBulb',
  initial: 'off',
  states: {
    off: {
      on: {
        TURN_ON: 'on'
      }
    },
    on: {
      on: {
        TURN_OFF: 'off',
      }
    }
  }
});

The state machine defined here shows the two states for the light bulb, OFF and ON, and the transitions from the events TURN_ON and TURN_OFF.

The object itself isn't very complex to read, but as the state machine grows in complexity, it can be harder to understand. XState has create a tool to help out with this - the XState visualizer.

Using the XState visualizer helps to see how the state machines work and are interactive, so playing with them is fun. If you want to check out the code for the machine, you can also click the code button to take a peek.

Building a Vonage Video State Chart

When I set out to learn state machines, and XState, my overall goal was to build an application similar to Google Meet using Vonage Video. The app would allow a user to create a meeting room, share the URL, and have a meeting with multiple streams. To get to that point, I had to learn some of the various concepts for state charts and how to represent those in XState.

Thinking through the possible application states is not an easy task, I found. There are many possibilities to explore, and ultimately finding the right solution takes some trial and error.

The rest of this article will cover some basic concepts and build a state chart visualization that will mimic the eventual state machine. I will also provide some additional links and resources throughout so you can explore on your own.

States and State Nodes

A state is a representation of a machine at any given time. This moment can be defined and then made into a state node in XState, captured as a configuration.

In my Vonage Video app, there are a couple of different possible solutions to this, but I've found that describing the states in as simple of terms as possible is the best way to get to a useful result.

Creating a machine uses the following pattern:

const machine = Machine(state_nodes, options)

With a video state machine in mind, there are two compound states - connected and disconnected.

Two state nodes may seem overly simplified, but there are only two states after some trial and error. Each of these states, however, are more complex than an atomic (no children) node. Instead of creating every possible state at the top level, XState helps us organize with hierarchical and parallel state nodes.

Hierarchical State Nodes

XState provides the option to create nested states called hierarchical state nodes. When we first start the machine, we can set it to idle first, as the machine will be ready but doing nothing. Why not just make another top-level atomic state node?

Adding states to the top level is called "state explosion" and is a typical side-effect of finite state machines. Since Vonage Video is still technically disconnected, nesting idle makes sense as the video is both disconnected and idle. Another disconnected substate should be ready. The disconnected.ready state would happen just before moving to the connected state. The state machine also has a state node in-between idle and ready to get everything set up. This middle state can be called the init phase.

The state machine now would look like this:

You should notice that we don't currently have a way to move in between the two nodes. We will cover events and actions in a moment.

Parallel State Nodes

A parallel state node allows the application to be in all of its substates at the same time. The Vonage Video state machine is highly event-driven, so we need to manage multiple states at once.

To specify that a state node is parallel, we use type:parallel in the configuration. After the transition to connected, three parallel states will occur - session, publisher, and subscribers. Each of these states will set up events and event listeners to control the Vonage Video service's responses.

The resulting visualization looks like this:

With these primary states, we can control what our application shows at particular times. Currently, however, we are unable to move between states. Let's have a look at events and transitions.

Events and Transitions

Since a state node is just the configuration of an individual state, their inherently is not a way to move from state to state without declaring that in the state node.

Each node listens for a sent event to transition to the next state. In the light bulb example, the TURN_ON event sent tells the machine to transition to on.

Transitions only occur between top-level nodes and within hierarchical nodes. Parallel nodes are not allowed to transition between each other. For our Vonage Video app, this means the following:

1. When the page is ready, we can send a START event. This event will transition the state to disconnected.init.
2. The disconnected.init state will transition out once the VIDEO_ELEMENT_CREATED event has fired.
3. Once we reach disconnected.ready, we can allow the user to connect, sending the CONNECT event, and transition to connected.
4. If the application passed the DISCONNECT event, the state machine would disconnect.

Declaring an event and transition in XState uses the following pattern:

on: {
  EVENT_DESCRIPTOR: 'nextState'
}

You can add specific actions to the transition as well. I would recommend you read the sections on internal and external transitions in the documentation. They cover in great detail the various types of transitions possible.

Guarded Transitions

You may have noticed that one of the transitions has a cond node in the transition. This conditional is what's called a guarded transition. Guarded transitions help protect the machine from moving to a state that is not allowed based on certain conditions. In this case, I don't want to transition to ready until the token and video element are both created.

on: {
  'VIDEO_ELEMENT_CREATED': {
    target: 'ready',
    cond: 'checkToken'
  }
}

The guard condition checkToken is a named reference to the guards object in the options paramater sent to machine:

const video = Machine(
  state_nodes,{
  guards: {
    checkToken: () => true
  }
});

Context

In order to be more useful to an application, our state machine will need a longer living state, called an extended state, or context. The context object updates using various effects with the assign() method.

Speaking of actions, let's get to these now and finish out the rest of the skeleton.

Actions and Services

There are what's known as "side-effects" in state machines that XState puts into one of two categories:

1. "Fire-and-forget" - where the effect doesn't send events
2. Invoked - where sending events are required

Actions

Actions are single effects and tend to be one of the more common effects in the video state machine. You can use actions when you enter or exit a node, or during a transition. Understanding the order of actions is incredibly important.

An excellent resource for learning the action order (and all of the topics on XState) is a video published by @kyleshvlin over at Egghead.io. It helped me understand how actions fired.

The bulk of the actions for this machine revolve around updating the context as a transition. When events are called, we can use the action to run the assign() method:

on: {
  'SOME_EVENT': {
      actions: assign({'someContext': (ctx, e) => e.someValue})
  } 
}

Services

Invoked Services are the other main effect in the video state machine. To use promises and event listeners, you need to invoke a service. This concept was, by far, the hardest for me to grasp. The main difficulty I had to work through was understanding that an invoked service stops when the state exits. If you transition too quickly, your promise or callback will disappear.

There are two primary services that I'm using in the video state machine, promises, and callbacks. The invoke promises service allows the state machine to use a promise to either resolve or reject and then act accordingly. I used this to interact with the server asynchronously and then update the context when complete.

The function signature of invoked promises looks like this:

src: (context, event) => new Promise((resolve, reject) => {
  if (event.error) reject('Rejected')
  resolve('Resolved')
}),
onDone: {/*success transition*/}
onError: {/*error transition*/}

The second, and probably the most important part of this machine, is the invoked callbacks. The Vonage Video architecture relies heavily on events and event listeners. In a state machine, those are set up through a callback. Let me show you an example:

invoke: {
  id: 'initPublisher',
  src: (ctx) => (cb) => {
    let publisher = initPublisher(pubOptions);
    publisher.on('videoElementCreated', (e) => {
      cb({ type: 'VIDEO_ELEMENT_CREATED', publisher: publisher })
    })
    return () => publisher.off('videoElementCreated');
  }
}

The function signature of an invoked callback looks like this:

src: (context, event) => (callback, onReceive) => {

  callback('EVENT');
  onReceive(event) => { callback('OTHER_EVENT') };

  return () => cleanup()
};

Using actions and services, our Vonage Video state machine now looks like the following:

Don't forget to click around, and click the code tab to see what the state machine looks like as a configuration.

Resources and Wrap-up

Ok - so you've made it this far.

If this is your first time looking at XState, it's a lot to take in all at once. I'm still exploring and learning new ways to do things. This post is just a small portion of what's out there. As you are learning - here are a few great resources you will want to check out

• Kyle Shevlin's Intro to State Machines Using XState videos
• XState Docs
• Introduction to XState at flaviocopes.com
• The Rist of State Machines - Smashing Magazine

Feel free to reach out if you have questions about XState, and we can learn something new together!

Prerequisites

For this tutorial, you are connecting a Dialogflow agent with the Vonage Messages API using Firebase. When complete, you can send a message in Facebook Messenger to the Dialogflow agent and get a response based on the agent's rules.

You'll want to make sure you have:

• Google Cloud Account
• Firebase CLI
• Vonage Messages API Sandbox

Create a Firebase Application

If this is your first time setting up a Firebase project, I would recommend you work through Google's Firebase getting started tutorial first to get yourself acclimated to the environment. If you are accustomed to Firebase or feeling adventurous, the first step is to create a new Firebase project. Feel free to name this anything memorable.

Once through the initial creation process (less than 5 minutes), set up these two items in the dashboard of your project:

1. Upgrade to Blaze Pay-As-You-Go You can locate this under Settings -> Usage and Billing -> Details & Settings -> Modify Plan. Firebase requires Blaze for any 3rd party integrations to work.
2. Pick a Resource Location Find this in Settings -> Project Settings -> General

Once those are all set, you can set up the Dialogflow agent and associate it with the new Firebase/GCP project.

Set Up Dialogflow Agent

Now you are ready to create a new Dialogflow agent—the chatbot that you will be interacting with later. Dialogflow uses Natural Language Processing to determine the user's intents based on what they type or speak and return an action based on that intent.

Next, import a "Prebuilt Agent" provided by Google to help get you started. If you are new to DialogFlow, you need to create a blank agent on the landing page.

Once you have an agent, you can select the "Prebuilt Agents" from the left menu. You are presented with many different types of agents that might help you start learning how to build your chatbot. For this example, I picked "Easter Eggs."

Import an agent and wait for it to complete the build process. Once finished, get the credentials for the service account.

Download Service Account Keys

Navigate to the GCP IAM & Admin service for service accounts. Make sure you select the correct project that you have been using already.

You should see a service account that looks similar to dialogflow@myexampleproject.iam.gserviceaccount.com. Click the dots on the right and select Create Key and then pick JSON from the options. This process generates and downloads a JSON file. Save this file for later.

Build Functions Locally

You now have a Firebase project and a Dialogflow agent ready to go. The two systems need to communicate with each other and with Vonage APIs. To do that, you need a little code to make things work.

The Firebase CLI has some helpful tools to get you started. Make sure you have the latest version and run the following:

firebase init functions

This command creates the project inside your root folder and asks you to connect it to an already existing project. After a few prompts, the command runs npm install to install all of the requirements. Once complete, navigate to the functions folder and use this command to install the other packages you need:

npm i @google-cloud/Dialogflow axios

At this time, you should also move the service account JSON file over to the functions directory. Once you've done that, make sure to add it to your .gitignore file as well.

The Code

Inside the functions directory is index.js. They provide some sample code to get you started, but you can delete and replace it with the following code to send a message to the Vonage Messages Sandbox. Make sure to have your Vonage API key and secret handy for this.

const functions = require('firebase-functions');
const axios = require('axios');
// the service account JSON file downloaded earlier - make sure this is named properly
const serviceAccount = require('./service_account.json');
const Dialogflow = require('@google-cloud/Dialogflow');
// This method takes the TO_ID, FROM_ID, MSG from the webhook defined later
// DialogFlow responses will be sent using this function
// You will need to get your API Key and Secret from the Vonage Dashboard.
function sendMessage(TO_ID, FROM_ID, MSG) {
  return axios.post('https://messages-sandbox.nexmo.com/v0.1/messages', {
    "from": { "type": 'messenger', "id": FROM_ID },
    "to": { "type": 'messenger', "id": TO_ID },
    "message": {
      'content': {
        'type': 'text',
        'text': MSG
      }
    }
  }, {
    auth: {
      username: 'API_KEY',
      password: 'API_SECRET'
    }
  })
}

The next function is the gateway between Firebase and Dialogflow. The incoming message from Vonage is sent to the Dialogflow agent to determine the intent of the message. Once the intent is determined, Dialogflow passes back a message to forward on to the client.

async function DialogflowGateway(text, sessionId) {
  const sessionClient = new Dialogflow.SessionsClient({ credentials: serviceAccount });
  const sessionPath = sessionClient.projectAgentSessionPath('YOUR-GOOGLE-PROJECT', sessionId);
  const request = {
    session: sessionPath,
    queryInput: {
      text: {
        text: text,
        languageCode: 'en-US',
      },
    },
  };
  console.log(request)
  return sessionClient.detectIntent(request);
}

The Vonage Messages Sandbox uses an inbound webhook to receive the messages using a POST method to Firebase.

exports.webhook = functions.https.onRequest(async (req, res) => {
  const { message, from, to } = req.body;
  try {
    // the message from the user is sent to Dialogflow, and a response is returned
    const response = await DialogflowGateway(message.content.text, from.id);
    // the response from Dialogflow is sent back to the user through Vonage
    await sendMessage(from.id, to.id, response[0].queryResult.fulfillmentText);
  } catch (error) {
    console.error(error);
  }
  res.sendStatus(200);
});

These three functions should be inside the index.js file and saved. All that is left is to deploy these functions.

Deploy Functions

Using the Firebase CLI, deploy the functions to Firebase using this command:

firebase deploy --only functions

On successful deployment, you get the webhook required for the Vonage Messages Sandbox Inbound webhook.

✔  functions: Finished running predeploy script.
i  functions: ensuring required API cloudfunctions.googleapis.com is enabled...
✔  functions: required API cloudfunctions.googleapis.com is enabled
i  functions: preparing functions directory for uploading...
i  functions: packaged functions (47.86 KB) for uploading
✔  functions: functions folder uploaded successfully
i  functions: creating Node.js 8 function webhook(us-central1)...
✔  functions[status(us-central1)]: Successful create operation.
✔  functions[webhook(us-central1)]: Successful create operation.
Function URL (webhook): https://us-central1-myexampleproject.cloudfunctions.net/webhook
✔  Deploy complete!

Once you have the webhook updated, you can test it out on Facebook Messenger.

Feel free to change intents and actions in Dialogflow to start to see how it can work in your communication strategy.

If you'd like to see a full version of this and other Google Cloud examples, you can find it here - https://github.com/nexmo-community/google-cloud-sample-code. If you have any questions or requests for other examples with Google Cloud, Dialogflow or Firebase, open up a pull request or shoot me a message on Twitter.

So I set out to build some tooling in Firebase to get me going. The first step I wanted to take, however, was securing the phone numbers that have access, and I thought it would be a perfect time to try out the Verify API. It's admittedly a bit over-the-top since this isn't a distributed app, but for safety, a phone number must go through the verification process to access my devices.

Verify API

The Verify API is a way to confirm that the phone belongs to the user. Performing the verification helps protect against spam and suspicious activity, as well as validating ownership.

The API itself has quite a lot packed into it. Its configuration options let you build the exact workflow that works for your system. As an example, the default workflow sends an SMS with a PIN code, waits 125 seconds, then calls with a Text-to-Speech event, waits 3 additional minutes, then calls again, and waits 5 minutes before expiring the request altogether.

I like having this level of control over something like this as it allows me to be very specific about how I can interact with my users. In my particular instance, I kept it very simple and did just one SMS message that expired in two minutes, since I wanted this mostly for my own purposes.

    let opts = {
      number: context.params.phoneNumber,
      brand: "Total Home Control",
      workflow_id: 6,
      pin_expiry: 120
    };

If you want to get started with the Verify API, you can sign up for a Vonage account today to get going.

Firebase Functions

Since I decided on using Firebase and Firestore, setting up some Cloud Functions to interact with the data and the Verify API was my next step. Each time a new phone number was created, I wanted to send it a verification code and then have a function to check the code.

Promises, Promises

When you first learn Cloud Functions, you may try some simple operations and build your confidence, which is what I did. After going through some of the simple functions first, I figured I'd be able to build this out fairly quickly.

And I was wrong. One detail I completely overlooked is that callback methods do not evaluate in the Cloud Function environment the way they do in other environments. Once there is a returned value or promise, the CPU stops. Since the Nexmo JavaScript SDK is running on callback methods, it stops processing.

Not knowing this had to be one of the more frustrating problems I've run into in a long time. The timing of everything was weird because the call back would run when I tried again, causing me to think I wasn't waiting long enough or the latency was terrible.

Once I sorted that out, I realized I needed to create Promise wrappers for the SDK methods, and everything worked perfectly. If you want some useful tips & tricks, I recommend reading this Firebase documentation guide.

Requesting the Verify Code

The Verify request method in the Vonage JavaScript SDK is quite minimal code, as the framework there makes it simple to do most everything. The first thing I had to do was wrap it in a promise.

function verifyRequest(opts) {
  return new Promise((resolve, reject) => {
    nexmo.verify.request(opts, (err, res) => {
      if (err) reject(err);
      resolve(res);
    })
  });
}

Creating this wrapper allows the callback method to run and return as a Promise resolution, instead of being ignored.

With this method, I could now create a Firebase function to run when the app added a new number to Firestore.

exports.requestVerify = functions.firestore.document('/phoneNumbers/{phoneNumber}')
  .onCreate((entry, context) => {
    let opts = {
      number: context.params.phoneNumber,
      brand: "Total Home Control",
      workflow_id: 6,
      pin_expiry: 120
    };

    return verifyRequest(opts)
      .then((res) => {
        console.log(res);
        return admin.firestore().doc(`/phoneNumbers/${context.params.phoneNumber}`).update({ req_id: res.request_id })
      })
      .then((res) => console.log(res))
      .catch((err) => console.error(err));
  });

With the Verify API, we need to keep track of the request_id to use in the check process. I use this to indicate that the verification process started but has not yet been completed.

Checking the Verify Code

Same as the previous example, the SDK method needs to first be wrapped as a Promise.

function verifyCheck(opts) {
  return new Promise((resolve, reject) => {
    nexmo.verify.check(opts, (err, res) => {
      if (err) reject(err);
      resolve(res);
    })
  });
}

Once the user receives it, the React application asks for the code and then calls the function directly from the application, passing the request_id, and the code.

exports.checkVerify = functions.https.onCall((data) => {
  let opts = {
    request_id: data.req_id,
    code: data.code
  };

  return verifyCheck(opts)
    .then((res) => {
      if (res.status === "0") {
        return admin.firestore().doc(`/phoneNumbers/${data.phoneNumber}`).update({ req_id: null, verified: true });
      }
    })
    .then((res) => console.log(res))
    .catch((err) => console.error(err));
});

As long as the code checks out, the document updates to include a verified flag, and the process is over. There are error status responses to check for and respond to accordingly—for example, if the code has timed out. My app currently assumes it passes.

React App

I won't spend too much time explaining all the code I wrote for my app, but the highlights are adding the data, and then calling the Firebase function from the front end.

In my app, I have a form to add a new number, consisting of just the phone number field. On submission, it merely adds it to the database. I've also set up a Firebase context file that sets the connections between my app and Firebase, so I can easily import everything I need.

import { db, fb } from '../../context/firebase';

//-----//

function _handleSubmit(e) {
  e.preventDefault();

  let data = {
    owner: fb.auth().currentUser.uid,
    verified: false,
  };

  return db.collection('phoneNumbers').doc(phoneNumber).set(data);
}

//-----//

The verification is nearly the same form with a similar submit method.

import { functions } from '../../context/firebase';

//-----//

function _handleSubmit(e) {
  e.preventDefault();
  var checkVerify = functions.httpsCallable('checkVerify');
  checkVerify({ code: code, req_id: value[0]?.data().req_id, phoneNumber: value[0]?.id }).then(function (result) {
    //close the form
  });
}

//-----//

The Firebase SDK provides a functions export to let you use httpsCallable() and name the function. Instead of needing to write any HTTP requests and waiting on those, this simplifies the process.

Sample Code

You can find my sample application code here. The app I built is more of a personal app for me, but feel free to have a look and use anything you might find useful.

Building the WebSocket

What's a WebSocket?

For this demo, I decided that using a WebSocket would be a great solution. If you haven't used a WebSocket before, it's a protocol that allows a client and server to communicate in real-time. WebSockets are bi-directional, meaning the client and server can both send and receive messages. When you first connect to a WebSocket, the connection is made by upgrading an HTTP protocol to the WebSocket protocol and is kept alive as long as it goes uninterrupted. Once established, it provides a continuous stream of content. Exactly what we need to receive incoming, translated SMS messages.

Create the WebSocket Server in Node

As an initial step to creating the WebSockets, the server requires a path to allow for client connections. Starting with the original server file from my previous post, we can make a few minor changes to create the WebSocket server and the events and listeners required by the client.

Using the ws package on NPM, we can quickly create what we need to get this working.

npm install ws

Once installed, include the package in your server file, and create the WebSocket server. WS allows a path option to set the route the client uses to connect.

const express = require('express');
const WebSocket = require('ws');

const app = express();
const server = http.createServer(app);
const wss = new WebSocket.Server({ server, path: "/socket" });

With this bit of code, the client now has a place to connect to the WebSocket route /socket. With the server ready to go, you need to now listen for a connection event. When the client connects, the server uses the following to set up the other listeners we need:

wss.on('connection', (ws) => {
  ws.isAlive = true;
  ws.translateTo = 'en';

  ws.on('pong', () => {
    ws.isAlive = true;
  });

  ws.on('message', (message) => {
    translateTo = message;
  });

});

There are two main points to call out:

1. On connection, we set the property isAlive to true, and listen for the pong event. This event is for the server to check and maintain a connection with the client. The server sends a ping and responds with pong to verify it's still a live connection.
2. Here I set up translateTo as a property to store. translateTo is set through each client using a dropdown. When someone using our booth demo app selects a different language, that action sets this to translate the SMS texts into the requested language.

Keeping the Connection Alive

One essential item to be concerned with is checking for clients that disconnect. It's possible that during the disconnection process, the server may not be aware, and problems may occur. With a good friend setInterval(), we can check if our clients are still there and reconnect them if needed.

setInterval(() => {
  wss.clients.forEach((ws) => {
    if (!ws.isAlive) return ws.terminate();
    ws.isAlive = false;
    ws.ping(null, false, true);
  });
}, 10000);

Sending Messages to the Client

Now that the WebSocket is connected and monitored, we can handle the inbound messages from Nexmo, the translation, and the response to the client. The method handleRoute needs to be updated from its original state to add the response for each client.

const handleRoute = (req, res) => {

  let params = req.body;

  if (req.method === "GET") {
    params = req.query
  }

  if (!params.to || !params.msisdn) {
    res.status(400).send({ 'error': 'This is not a valid inbound SMS message!' });
  } else {
    wss.clients.forEach(async (client) => {
      let translation = await translateText(params, client.translateTo);
      let response = {
        from: obfuscateNumber(req.body.msisdn),
        translation: translation.translatedText,
        originalLanguage: translation.detectedSourceLanguage,
        originalMessage: params.text,
        translatedTo: client.translateTo
      }

      client.send(JSON.stringify(response));
    });

    res.status(200).end();
  }

};

The wss.clients.forEach method iterates through each connection and sends off the SMS parameters from Nexmo to the Google Translate API. Once the translation comes back, we can decide what data the front-end should have, and pass it back as a string as I've done here with client.send(JSON.stringify(response)).

To recap what has happened here: Each client connects to the WebSocket server by calling the /socket route and establishing a connection. An SMS message goes from the sender's phone to Nexmo, which then calls the /inboundSMS route. The app passes the text message to Google Translate API for each connected client, and then finally sends it back to the client UI.

Next, let's build the UI parts to display it on the screen.

WebSockets with React

With the WebSocket server running, we can move on to the display of the messages on screen. Since I enjoy using React, and more importantly, React Hooks, I set out to locate something to help with connecting to WebSockets. Sure enough, I found one that fit my exact need.

The demo app UI is built with create-react-app, and I used the Grommet framework. These topics are out of scope for this post, but you can grab my source code and follow along.

Connecting to the WebSocket

The first step here is to establish a connection and begin two-way communication. The module I found is react-use-websocket, and it made setting this up super simple.

npm install react-use-websocket

There are tons of these React hook libraries out there that help you create some impressive functionality in a short amount of time. In this instance, importing the module and setting up a couple of items for the configuration is all it took to get a connection.

import useWebSocket from 'react-use-websocket';

const App = () => {
  const STATIC_OPTIONS = useMemo(() => ({
    shouldReconnect: (closeEvent) => true,
  }), []);

  const protocolPrefix = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
  let { host } = window.location;
  const [sendMessage, lastMessage, readyState] = useWebSocket(`${protocolPrefix}//${host}/socket`, STATIC_OPTIONS);

  //...
}

In the component, we import the useWebSocket method to pass the WebSocket URL and the object STATIC_OPTIONS as the second argument. The useWebSocket method is a custom hook that returns the sendMessage method, lastMessage object from the server (which is our translated messages), and the readyState which is an integer to give us the status of the connection.

Receiving Incoming Messages

Once react-use-websocket makes the connection to the server, we can now start listening for messages from the lastMessage property. When receiving incoming messages from the server, they populate here and update the component. If your server has multiple message types, you discern that information here. Since we only have one, it's an easier implementation.

const [messageHistory, setMessageHistory] = useState([]);

useEffect(() => {
  if (lastMessage !== null) {
    setMessageHistory(prev => prev.concat(lastMessage))
  }
}, [lastMessage]);

return (
  <Main>
    {messageHistory.map((message, idx) => {
      let msg = JSON.parse(message.data);
      return (
        <Box>
          <Text>From: {msg.from}</Text>
          <Heading level={2}>{msg.translation}</Heading>
        </Box>
      )
    })}
  </Main>
)

The built-in hook useEffect runs every time the state is updated. When lastMessage is not null, it adds the new message to the end of the previous message state array, and the UI updates using the map function to render all of the messages. It is in the messageHistory where all of the JSON strings we passed from the server are stored. The main functionality of our WebSocket is complete, but I still want to add a few more items.

Sending Messages to the Server

Since this is a translation demo, having more than one language is an excellent way to show the power of the Google Translate API in conjunction with Nexmo SMS messages. I created a dropdown with languages to pick. This dropdown is where bi-directional communication happens with the server, and the app sends the selected language from the client.

const languages = [
  { label: "English", value: "en"},
  { label: "French", value: "fr"},
  { label: "German", value: "de"},
  { label: "Spanish", value: "es"}
];

<Select
  labelKey="label"
  onChange={({ option }) => {
    sendMessage(option.value)
    setTranslateValue(option.label)
  }}
  options={languages}
  value={translateValue}
  valueKey="value"
/>

Here, the sendMessage function from react-use-websocket is how we can send information back to our server and consume it. This process is where the event handler we set up comes in handy from earlier. It is this dropdown that determines what language the Google Translate API translates the message into and displays on the screen.

Connection Status Display

Since this is a demo in a conference environment, I thought having a connectivity indicator would be a good idea. As long as the front-end remains connected to the WebSocket, the light displays green.

const CONNECTION_STATUS_CONNECTING = 0;
const CONNECTION_STATUS_OPEN = 1;
const CONNECTION_STATUS_CLOSING = 2;

function Status({ status }) {
  switch (status) {
    case CONNECTION_STATUS_OPEN:
      return <>Connected<div className="led green"></div></>;
    case CONNECTION_STATUS_CONNECTING:
      return <>Connecting<div className="led yellow"></div></>;
    case CONNECTION_STATUS_CLOSING:
      return <>Closing<div className="led yellow"></div></>;
    default:
      return <>Disconnected<div className="led grey"></div></>;;
  }
}

//....
<Status status={readyState} />
//...

The Status component uses the readyState to switch between the various statuses and indicates that to the user. If it turns red, you know something is wrong with the WebSocket server, and you should check into it.

Once everything is up and running, it looks something like this:

Try It Out

The demo application code is on our community GitHub organization, and you can try it out for yourself as well. I've created a README that should help you get through the setup and run it locally on your server or deploy it to Heroku. I've also provided a Dockerfile, if you'd prefer to go that route. Let me know what you think of it, and if you have any trouble, feel free to reach out and submit an issue on the repo.