Forem: Diana 🦪

Migration from Twilio to Vonage Video: Guides for Web, iOS, and Android

Diana 🦪 — Tue, 14 May 2024 11:35:55 +0000

In case you missed it, Vonage is welcoming Twilio Programmable Video customers to switch to using the Vonage Video API! Don't worry; we wouldn't invite you over without providing resources for the migration. This blog will share our newest migration guides for Web (JavaScript), Android, and iOS.

The Difference

There's no debate that Twilio and Vonage share many concepts. The main difference is that, with Twilio, you have to create a room SID, while with Vonage, you create a sessionID. You then create authentication tokens used in the Vonage client SDKs to connect to a session. Once connected, clients can publish video/audio media streams and subscribe to the other client streams to create their real-time video applications.

Web (JavaScript) Migration

Vonage offers our Web developers and JavaScript fans the option to migrate their preexisting Twilio Video Web implementation to Vonage Video API.

The Vonage Video API is a customizable option that allows developers to integrate real-time video capabilities into their applications, covering 1:1 video calling, group video chat, and large-scale interactive broadcasts. It provides a set of APIs for building customized features such as dynamic video recording, SIP interconnect, signaling, and live captions. It also offers a range of customization options, allowing developers to tailor the UX and UI to fit their application's design. We provide a Twilio migration guide with simple steps to quickly switch from Twilio and build video chat and multiparty applications using the Vonage Video API.

iOS and Android Guides

The Vonage Video API provides client SDKs for various platforms, including iOS and Android that Twilio supported. (In fact, Vonage also supports Windows, Linux and MacOS). The iOS SDK allows developers to integrate real-time video communication features into their iOS applications, including iPhones and iPads. The Android SDK offers the same capabilities with Android devices. By following these migration guides for iOS and Android, you can convert your entire Twilio application to Vonage.

Come for the Video, Stay for APIs

Vonage offers more than just the Video API. We also offer Text, Messaging, Voice, Authentication, and other APIs for developers to build with. After being acquired by Ericsson, we've been growing and expanding our APIs with new 5G network-base capabilities and want you to be a part of it. Feel free to join our community Slack and follow us on X, formerly known as Twitter. If you end up trying out our migration guides and building with Vonage, please share them and tag me - I'd love to hear about your experience!

Working with Environment Variables in Java

Diana 🦪 — Fri, 22 Mar 2024 13:09:44 +0000

What is an Environment Variable?

Environment variables (sometimes called "env vars") are variables you store outside your program that can affect how it runs. You can later use that value to change how programs, applications, and services behave. Applications treat environmental variables like constants (a value that does not change during the program's execution) rather than mutable variables (a value that can change). They are best used with things you would typically consider hard coding but would rather keep the value out of your code, either because it will change between environments. You want to keep your code portable and easier to manage because you want to avoid leaking sensitive information such as your API key and password in less secure environments like development or testing.

Use Cases

Here are a few use cases for environmental variables:

Defining program arguments
Specifying domain names
Storing API keys
Setting path variables

Let’s dive into each!

Defining Program Arguments

How It Works: Developers use environment variables like ENV_MODE to indicate the current execution context of the application, such as development, testing, staging, or production.
Benefits: This allows the application to adapt its behavior based on the mode. For instance, in development mode, the application might enable verbose logging and debugging tools, whereas in production, these features are disabled for efficiency and security.
Implementation Example: In Java, you might check System.getenv("ENV_MODE") to configure database connections or error handling differently for each mode.

Specifying Domain Names

How It Works: Environment variables like SERVICE_URL can store domain names or URLs that the application might need to access.
Benefits: This is particularly useful for applications that interact with different endpoints or services in different environments. By changing the environment variable, you can redirect your application to use a different domain without altering the code.
Implementation Example: In a Java-based web application integrating Vonage services, the endpoint URL for Vonage's API can be defined using an environment variable, like VONAGE_API_URL. This allows developers to switch between a local development environment and a production server by simply changing the value of the environment variable. The application retrieves this URL with System.getenv("VONAGE_API_URL").

Storing API Keys

How It Works: Sensitive information such as API keys can be stored in environment variables, for instance, API_KEY.
Benefits: This practice keeps sensitive data out of the source code, enhancing security. It also makes it easy to update keys without needing to touch the codebase, and different keys can be used in different environments.
Implementation Example: In a Java application using Vonage services, the Vonage API key can be stored in an environment variable, such as VONAGE_API_KEY. To access this key, the application would use System.getenv("VONAGE_API_KEY"). This approach ensures the API key is not embedded in the source code or exposed in version control, enhancing security while providing access to Vonage's telecommunication services.

Setting Path Variables

How It Works: Environment variables like LOG_PATH or CONFIG_DIR can be used to specify the application's directory paths for logging, configuration files, or other purposes.
Benefits: This allows for flexible file management, as paths can be changed per environment without code changes. It’s beneficial for applications on multiple platforms (like Windows and Unix), where directory structures can vary significantly.
Implementation Example: In a Java application, reading a configuration path from an environment variable allows it to quickly adapt to different file system layouts across development and production servers or operating systems.

In all these cases, environment variables provide a layer of abstraction that separates configuration details from the application logic. This separation not only enhances security and maintainability but also increases the adaptability of the software to different environments and conditions.

Getting Environmental Variables

Accessing environment variables in Java is straightforward and can be done using the System class provided by the standard Java library. Here's a simple guide on how to do it:

Get a Single Environment Variable: Use the System.getenv(String name) method to retrieve the value of a specific environment variable. For example, to access an environment variable named API_KEY, you would use:

String apiKey = System.getenv("API_KEY");

Check for Null Values: It's a good practice to check if the environment variable is null (i.e., not set) to avoid potential NullPointerExceptions. For example:

String apiKey = Optional.ofNullable(System.getenv("API_KEY")).orElse(otherValue);

where otherValue is the fallback. You can throw an exception instead if the environemnt variable is missing like so:

Optional.ofNullable(System.getenv("API_KEY")).orElseThrow(() -> new IllegalStateException("API_KEY env var is not defined"));

Get All Environment Variables: To get a Map<String, String> of all environment variables, use System.getenv(). This is useful if you want to iterate over all available environment variables. For example:

Map<String, String> envVars = System.getenv();
for (String envName : envVars.keySet()) {
    System.out.format("%s=%s%n", envName, envVars.get(envName));`
}

Alternatively, this can be written in one line:

System.getenv().forEach((k, v) -> System.out.println(k+"="+v));

Setting Environmental Variables

Setting environment variables directly within a Java application is not straightforward because environment variables are typically set at the operating system level and are read-only without an argument. However, there are a few ways you can work around this limitation, depending on your use case:

Set Environment Variables Before Running Java Application

The most common approach is to set environment variables in your operating system before starting your Java application. This can be done in the command line or through scripts.

For example, in a Unix environment, you can set an environment variable in the terminal like this:

export MY_VAR="some value"

In Windows Command Prompt, it would be:

set MY_VAR=some value

Set for Sub-Processes

If you need to set environment variables for subprocesses started from your Java application (and not for the Java process itself), you can use the ProcessBuilder class:

ProcessBuilder processBuilder = new ProcessBuilder();
Map<String, String> env = processBuilder.environment();
env.put("MY_VAR", "some value");
Process process = processBuilder.start();

Set Environment Variables in IDE

If you are using an Integrated Development Environment (IDE) like IntelliJ IDEA or Eclipse, you can set environment variables in the configuration settings of your application.

Set Environment Variables in Build Tools

When using build tools like Maven or Gradle, you can configure environment variables in the build scripts or configuration files.

Loading Configurations From a File

Since java.util.Properties implements the Map interface, you can load any file which maps key-value pairs like so, irrespective of its file extension:

var props = new Properties();
var envFile = Paths.get("/path/to/MyEnvConfig.env");
try (var inputStream = Files.newInputStream(envFile)) {
    props.load(inputStream);
}
String apiKey = props.get("VONAGE_API_KEY");
String apiSecret = props.get("VONAGE_API_SECRET");

Share Your Best Practices

Getting and setting environment variables is an essential part of creating production software. If you’ve reached the end of this article, you’re now familiar with what environment variables are, use cases, how to get and set environment variables, and using .env files in Java. Feel free to join our community Slack and follow us on X, formerly known as Twitter. Do you have other best practices using environmental variables? Please share them and tag me - I'd love to hear about them!

Things I asked the DevAd hiring manager before verbally accepting the intern offer

Diana 🦪 — Sun, 02 Jan 2022 04:24:21 +0000

As I prepare for my third and last internship before graduation, I thought it would help to articulate details I needed to know about a role before signing my soul away.

I had the luxury of meeting with my future manager a few times before making my decision, so I made sure each call was productive and insightful since I only had those moments to decide if vibes check out.

What is the intern project?

I've learned to run for the hills when a hiring manager is extremely vague or even unsure about what they want me to work on. First, it comes off open-minded and flexible which is really intriguing. But then I find myself gaslit and working on something I absolutely did not want to do.

I'd love to know:

What product I'll be working with
What specific topics I'll be covering
What my final project will be

I've narrowed my choices of employers based on (1) products that interest me and (2) projects assigned. I learned I don't make a good sellout, and there was no way I'd make a decent devad if I wasn't working on something I enjoyed.

Why are you hiring an intern specifically on this team?

I was once brought onto a team as an impromptu intern (ie. they made my role because I was referred). During my first week, I approached my manager with a list of clarifying questions including "What are your expectations of me in order to get a return offer on this team?" (Something I was taught to ask early on and a previous internship had addressed on my first day) Had I not asked this, I probably wouldn't have ever learned that this team wasn't even hiring.

That conversation turned into a real sh!t show, but my point is: Please don't bring an intern on without intent to keep them.

Is mentorship offered? If yes, what's your style?

When hearing about my classmates who interned at Amazon, I envied the kind of mentorship they received. It was very organized and systematic, and expectations of the mentor were crystal clear. I never felt like I really had that. It's not their fault; none of my assigned mentors were given instructions on how to contribute to my internships. Some of them didn't even know what being a mentor entailed.

Ideally I would like an empathetic mentor(s) who can:

willingly take on questions
train me but understand I'm likely unable to perform at their level in the time I'm interning
help unblock me after I've tried to solve a problem
offer constructive feedback (I don't want to think I'm doing fine then get blindsided)
offer the amount of guidance I need
carve out time to have involved 1:1's; if they're busy, we can move it (I don't want a mentor who is constantly working on other things every time we meet while I'm trying to talk to them)

What are the expectations to get a return offer?

I was once told it was "extremely off-putting" that I had asked about what is expected of me in order to get a return offer because it came off "entitled that I even thought it was a possibility to return to the team." I hated that I tip-toed around this question for countless talks every since, but I've spoken to enough people now to confirm that that isn't an offensive question and it's completely normal to want to know this information.

I asked if we could establish some metrics we can refer to (e.g. How many videos am I expected to make?), so I have some level of self-awareness. I get that solely reaching a count isn't all it takes, but I just want some way of knowing how much I've done and how much I have left to do.

Are you crazy? (Please don't ask this verbatim)

"I just wanted to make sure you're not crazy."

Lacks context but yes...I did actually say the above sentence verbatim.

Admittedly, it was unnecessarily vulnerable to share my story about being expected to work normally after 3 deaths in my family during a past internship. I'm sure there were other ways to find out whether my next boss understands that "life happens" and I'm a human-being before I'm an employee.

My point is: this was important to me, and I needed some reasurrance that I was going to work for a reasonable person.

Wrap up

When I got the offer, I had already chosen the company based on their size, pay, benefits, etc. The only thing left was choosing my manager.

My key determining factors when deciding on a manager were their:

assigned project
purpose for hiring an intern
mentorship style
expectations
response to emergencies

Can't wait to share my journey as a DevAd intern at Snowflake starting in February!