DEV Community: Wolk Software

Getting started with Azure functions v4 + Node.js & TypeScript

Remo H. Jansen — Tue, 02 May 2023 08:51:54 +0000

In this post, we are going to take a look at everything you need to know to get started with Azure Functions v4 (currently in preview). We will also take a look at some common use cases.

What are Azure functions?

An Azure Function App is a serverless compute service provided by Microsoft Azure, which allows developers to easily create and deploy small pieces of code, known as "functions," that can be executed in response to events or triggers. Azure Function Apps can be written in a variety of languages, including C#, F#, JavaScript, PowerShell, Python, and TypeScript.

The main advantage of Azure Function Apps over traditional API apps is that they are fully managed and scalable, meaning developers can focus on writing the code for the specific task at hand, without worrying about the underlying infrastructure or server management. Azure Function Apps are also pay-per-use, which means that developers only pay for the resources they consume while their functions are running, and they don't have to worry about paying for idle time or unused resources.

Azure Function Apps is that they can be integrated with a wide range of other Azure services, such as Azure Storage, Azure Event Hubs, Azure Service Bus, and Azure Cosmos DB, making it easy to build complex applications that leverage multiple Azure services. Additionally, Azure Function Apps can be used to build event-driven architectures, where functions can be triggered by events such as changes to a database, the arrival of a message in a queue, or the upload of a file to a storage account. This allows for highly scalable and reactive applications that can respond to changes in real-time.

What is exciting about Azure functions v4?

Version 4 was designed with the following goals in mind:

Provide a familiar and intuitive experience to Node.js developers
Make the file structure flexible with support for full customization
Switch to a code-centric approach for defining function configuration

The Node.js "programming model" shouldn't be confused with the Azure Functions "runtime".
Programming model: Defines how you author your code and is specific to JavaScript and TypeScript.
Runtime: Defines underlying behavior of Azure Functions and is shared across all languages.

The programming model version is strictly tied to the version of the @azure/functions npm package, and is versioned independently of the runtime. Both the runtime and the programming model use "4" as their latest major version, but that is purely a coincidence.

The V4 model uses an app object as the entry point for registering functions instead of function.json files. For example, to register an HTTP trigger responding to a GET request, you can call app.http() or app.get() which was modeled after other Node.js frameworks like Express.js that also support app.get().

HttpTrigger Handler (v3)

module.exports = async function (context, req) {
  context.log('HTTP function processed a request');

  const name = req.query.name
    || req.body
    || 'world';

  context.res = {
    body: `Hello, ${name}!`
  };
};

HttpTrigger Bindings (v3)

{
  "bindings": [
    {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "res"
    }
  ]
}

HttpTrigger Handler + Bindings (v4)

Trigger configuration like methods and authLevel that were specified in a function.json file before are moved to the code itself in V4. V4 also sets several defaults for you, which is why you don't see authLevel or an output binding in the V4 example.

const { app } = require("@azure/functions");

app.http('helloWorld1', {
  methods: ['GET', 'POST'],
  handler: async (request, context) => {
    context.log('Http function processed request');

    const name = request.query.get('name') 
      || await request.text() 
      || 'world';

    return { body: `Hello, ${name}!` };
  }
});

The V4 model, have adjusted the HTTP request and response types to be a subset of the fetch standard instead of types unique to Azure Functions. V4 uses Node.js's undici package, which follows the fetch standard and is currently being integrated into Node.js core.

HttpRequest - body (v3)

// returns a string, object, or Buffer
const body = request.body;
// returns a string
const body = request.rawBody;
// returns a Buffer
const body = request.bufferBody;
// returns an object representing a form
const body = await request.parseFormBody();

HttpRequest - body (v4)

const body = await request.text();
const body = await request.json();
const body = await request.formData();
const body = await request.arrayBuffer();
const body = await request.blob();

HttpResponse – status (v3)

context.res.status(200);

context.res = { status: 200}
context.res = { statusCode: 200 };

return { status: 200};
return { statusCode: 200 };

HttpResponse – status (v4)

return { status: 200 };

Folder structure (v3)

The required folder structure for a JavaScript project in V3 looks like the following:

FunctionsProject
 | - MyFirstFunction
 | | - index.js
 | | - function.json
 | - MySecondFunction
 | | - index.js
 | | - function.json
 | - SharedCode
 | | - myFirstHelperFunction.js
 | | - mySecondHelperFunction.js
 | - node_modules
 | - host.json
 | - package.json

Folder structure (v4)

The recommended folder structure for a JavaScript project in V4 looks like the following:

<project_root>/
 | - .vscode/
 | - src/
 | | - functions/
 | | | - myFirstFunction.js
 | | | - mySecondFunction.js
 | - test/
 | | - functions/
 | | | - myFirstFunction.test.js
 | | | - mySecondFunction.test.js
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - package.json

⚠️ Keep in mind that you can't mix the v3 and v4 programming models in the same function app. As soon as you register one v4 function in your app, any v3 functions registered in function.json files are ignored.

Create a new Azure function v4 project

The version 4 of the Node.js programming model requires the following minimum versions:

@azure/functions npm package v4.0.0-alpha.9+
Node.js v18+
TypeScript v4+
Azure Functions Runtime v4.16+
Azure Functions Core Tools v4.0.5095+

In Azure Functions, a function project is a container for one or more individual functions that each responds to a specific trigger. All functions in a project share the same local and hosting configurations.

Run the func init command, as follows, to create a functions project in a folder named MyFunctionApp:

func init MyFunctionApp --model V4

The command prompts you to select a runtime and language. Select node and typescript:

Select a number for worker runtime:
1. dotnet
2. dotnet (isolated process)
3. node
4. python
5. powershell
6. custom
Choose option: 3
node
Select a number for language:
1. javascript
2. typescript
Choose option: 2
typescript

Enable the v4 programming model

⚠️ During the V4 preview, you must set the app setting AzureWebJobsFeatureFlags to EnableWorkerIndexing.

The following application setting is required to run the v4 programming model while it is in preview:

Name: AzureWebJobsFeatureFlags
Value: EnableWorkerIndexing

If you're running locally using Azure Functions Core Tools, you should add this setting to your local.settings.json file:

{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "AzureWebJobsFeatureFlags": "EnableWorkerIndexing", // <-- HERE!
    "AzureWebJobsStorage": ""
  }
}

If you're running in Azure, follow these steps with the tool of your choice:

az functionapp config appsettings set --name <FUNCTION_APP_NAME>  \
--resource-group <RESOURCE_GROUP_NAME>  \
--settings AzureWebJobsFeatureFlags=EnableWorkerIndexing

Create a new function

Navigate into the project folder:

cd MyFunctionApp

This folder contains various files for the project, including configurations files named local.settings.json and host.json. Because local.settings.json can contain secrets downloaded from Azure, the file is excluded from source control by default in the .gitignore file.

Add a function to your project by using the following command:

func new

Choose the template for HTTP trigger. You can keep the default name (httpTrigger) or give it a new name (HttpExample). Your function name must be unique, or you're asked to confirm if your intention is to replace an existing function. You can find the function you added in the src/functions directory.

Select a number for template:
1. Azure Blob Storage trigger
2. Azure Cosmos DB trigger
3. Durable Functions entity
4. Durable Functions orchestrator
5. Azure Event Grid trigger
6. Azure Event Hub trigger
7. HTTP trigger
8. Azure Queue Storage trigger
9. Azure Service Bus Queue trigger
10. Azure Service Bus Topic trigger
11. Timer trigger
Choose option: 7
HTTP trigger
Function name: [httpTrigger] 
Creating a new file /src/functions/httpTrigger.ts
The function "httpTrigger" was created successfully from the "HTTP trigger" template.

The function will be created under /src/functions/httpTrigger.ts as follows:

import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

export async function httpTrigger(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || await request.text() || 'world';

    return { body: `Hello, ${name}!` };
};

app.http('httpTrigger', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: httpTrigger
});

We now need to add Azure Storage connection information in local.settings.json. If you don't have an Azure Storage account, you can use the Azurite to run a local storage emulator. You can install Azurite using the following command:

npm install -g azurite

You can then start Azurite by running the following command:

azurite

The easiest way to connect to the emulator from your application is to configure a connection string in your application's configuration file that references the shortcut UseDevelopmentStorage=true. The shortcut is equivalent to the full connection string for the emulator. In your Azure Functions project, open the local.settings.json file and update the connection string for your storage account:

{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "AzureWebJobsFeatureFlags": "EnableWorkerIndexing",
    "AzureWebJobsStorage": "UseDevelopmentStorage=true;DevelopmentStorageProxyUri=http://127.0.0.1:10000" // <-- HERE!
  }
}

Run your function by starting the local Azure Functions runtime host from the MyFunctionApp folder.

func start

The following output must appear:

Azure Functions Core Tools
Core Tools Version:       4.0.5095 Commit hash: N/A  (64-bit)
Function Runtime Version: 4.16.5.20396

[2023-04-14T19:50:22.069Z] Worker process started and initialized.
...
Functions:

        httpTrigger: [GET,POST] http://localhost:7071/api/httpTrigger

For detailed output, run func with --verbose flag.

Deploying your function app to Azure

First, you need to build your function app. This will create a dist folder with the compiled JavaScript files:

yarn build

Then, you need to create a ZIP file with the content of the dist folder, and the host.json and package.json files. You can use the following commands to do so:

rm -r ./dist/**/*.map
cp -r ./host.json ./package.json ./node_modules ./dist
rm -r ./dist/node_modules/@types/
rm -r ./dist/node_modules/azure-functions-core-tools/
rm -r ./dist/node_modules/typescript/
cd ./dist
mkdir dist
mv ./src ./dist/
zip -r ../deploy.zip ./*
cd ..

After running these commands, you should have a deploy.zip file in your project folder, with the following contents:

.
├── dist
│   └── src
│       └── functions
│           └── httpTrigger.js
├── host.json
├── package.json
└── node-modules

You can deploy the deploy.zip file to Azure using the Azure CLI:

az login
az account set --subscription YOUR-AZURE-SUBSCRIPTION-ID
az functionapp deployment source config-zip -g YOUR-RESOURCE-GROUP -n YOUR-FUNCTION-APP --src ./deploy.zip

Recipe 1: Working with environment variables

The az functionapp config appsettings list command returns the existing application settings, as in the following example:

az functionapp config appsettings list --name <FUNCTION_APP_NAME> \
--resource-group <RESOURCE_GROUP_NAME>

The az functionapp config appsettings set command adds or updates an application setting. The following example creates a setting with a key named CUSTOM_FUNCTION_APP_SETTING and a value of 12345:

az functionapp config appsettings set --name <FUNCTION_APP_NAME> \
--resource-group <RESOURCE_GROUP_NAME> \
--settings CUSTOM_FUNCTION_APP_SETTING=12345

The function app settings values can also be read in your code as environment variables:

process.env.CUSTOM_FUNCTION_APP_SETTING

When run develop a function app locally, you must maintain local copies of these values in the local.settings.json project file:

{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "AzureWebJobsFeatureFlags": "EnableWorkerIndexing",
    "AzureWebJobsStorage": "UseDevelopmentStorage=true;DevelopmentStorageProxyUri=http://127.0.0.1:10000",
    "CUSTOM_FUNCTION_APP_SETTING": 12345 // <-- HERE!
  }
}

Recipe 2: Accessing Azure resources from your function

If your application access other resources in Azure, you will need to create an application identity and grant it access to those resources. For example, you might want to access a Key Vault to retrieve secrets. You can do so by using the @azure/identity and @azure/keyvault-secrets packages:

yarn add @azure/identity @azure/keyvault-secrets

Then, you can write a function that retrieves a secret from Key Vault. The following example uses the DefaultAzureCredential class to authenticate with Azure Active Directory and then retrieves a secret from Key Vault:

import { DefaultAzureCredential } from "@azure/identity";
import { SecretClient } from "@azure/keyvault-secrets";

interface AppSecrets {
  // your secrets here
}

export async function getSecrets(): Promise<AppSecrets> {
  const keyVaultName = "your-key-vault-name";
  const KVUri = `https://${keyVaultName}.vault.azure.net`;
  const secretName = "your-secret-name";
  const credential = new DefaultAzureCredential(); // <-- HERE!
  const client = new SecretClient(KVUri, credential);
  const retrievedSecret = await client.getSecret(secretName);
  const value = retrievedSecret.value;
  if (value === undefined) {
    throw new Error();
  } else {
    return JSON.parse(value);
  }
}

If you run the previous code in an Azure function, it will fail because you need to create an application identity first. You can do so in the Azure portal:

Then, you need to grant the application identity access to the Key Vault:

Recipe 3: Working with Cosmos DB

You can use the @azure/cosmos package to access Cosmos DB from your function app. You could store your Cosmos DB connection string in the application settings, but it is better to store it in Key Vault and retrieve it using the getSecrets function from the previous recipe.

The following function retrieves the Cosmos DB connection string from Key Vault and then uses it to create a Cosmos DB configuration object:

import { getSecrets } from "./secrets";

export async function getDatabaseConfig(containerId: string, log: (txt: string) => void) {
    log('Invoking getDatabaseConfig...');
    const appSecrets = await getSecrets(log);
    return {
        endpoint: appSecrets.cosmosEndpoint,
        key: appSecrets.cosmosKey,
        databaseId: "wolkdotcomui",
        containerId: containerId
    }
}

You can then use the getDatabaseConfig function to create a Cosmos DB client and retrieve a container. You will need to install the @azure/cosmos package:

yarn add @azure/cosmos

The following function creates a Cosmos DB client and then retrieves a container:

import { Container, CosmosClient } from "@azure/cosmos";
import { getDatabaseConfig } from "./config";

export async function getDbContainer(containerId: string, log: (txt: string) => void): Promise<Container> {
    log(`Invoking getDbContainer... ${containerId}`);
    const dbConfig = await getDatabaseConfig(containerId, log);
    const { endpoint, key, databaseId } = dbConfig;
    const client = new CosmosClient({
        endpoint,
        key
    });
    const database = client.database(databaseId);
    const container = database.container(containerId);
    return container;
}

The container can then be used to retrieve items from Cosmos DB. For example, the following function retrieves a user from a container named users in Cosmos DB:

import { getDbContainer } from "../shared/db";

export interface User {
    id: string;
    name: string;
    email: string;
}

export async function getUserById(id: string): Promise<User> {
    const containerId = 'users';
    const dbContainer = await getDbContainer(containerId, log);
    const item = dbContainer.item(id, id);
    const response = await item.read<User>();
    if (response.resource) {
        throw new Error('User not found');
    }
    return response.resource; 
}

You can then use the getUserById in your functions.

Recipe 4: Troubleshooting deployments

If after deploying your function app your application is not working you should head to the azure portal and check a few things:

Check the logs in the Log stream section of the portal.
Try to restart the function app from the Overview section.
Visit the App Service Editor (Preview) section of the portal to see the deployed files.
Visit the Functions section of the portal to see the deployed functions.

You can use the follwing URL to access the Debug Console:

https://<YOUR-APP-NAME>.scm.azurewebsites.net/DebugConsole

To download the ZIP file of the deployed application visit:

https://<YOUR-APP-NAME>.scm.azurewebsites.net/api/zip/site/wwwroot/

We hope that this post has been useful. If you have any questions or comments, please contact us via Twitter at @WolkSoftwareLtd.

The upcoming SaaS bubble burst

Remo H. Jansen — Fri, 07 Apr 2023 10:01:01 +0000

It is 2023 and we are not feeling bullish about the future of SaaS businesses.

It is 2023, and we are not feeling bullish on the future of SaaS businesses.

The recent mainstream conversation about generative AI advancements such as ChatGPT got us thinking about some of the broader implications for the software industry. When we think that with the power of AI, a software engineer can achieve superhuman productivity levels today, the first thing that comes to mind is how AI will disrupt most SaaS businesses over the next decade.

Are SaaS businesses protected against the competition?

Building a SaaS business is expensive for two main reasons.
Experimentation. First, you need to spend a considerable amount of money doing user research until you come up with a solution that is good enough to be purchased by customers.
Customer acquisition. Then you need to scale as fast as possible and capture as much market share as possible, spending a lot of cash on digital marketing.
The value of some solutions is fundamentally coupled with the number of users on the platform. For example, any kind of market matching platform becomes more valuable as the number of users grows. In such cases, capturing enough market share becomes a barrier to entry for competitors and protects the business's long-term success.

Other SaaS solutions, such as payment solutions, also present obstacles to competition due to the expenses associated with fraud prevention and compliance with central banks and other financial markets regulators such as the SEC or the ESMA.

Most SaaS solutions don't present these barriers to entry for competitors. Think about HR, accounting, project management or marketing solutions. In most cases, the number of users on the platform is entirely irrelevant to the customers (beyond the service provider's financial stability).

The principal value proposition of Saas companies is a good user experience and convenience (e.g. always available, automated updates, no need to install). One of the biggest problems is that patents do not protect most SaaS solutions. Individual algorithms must be patented, but user experience and convenience can not.

The reality is that, in most cases, nothing is protecting SaaS businesses from competition other than the initial upfront investment in experimentation and the customer acquisition costs.

How are SaaS businesses going to be disrupted?

Cloud computing is mature today, and a single developer could easily manage to scale and serve millions of customers. The rise of AI can make individual developers reach superhuman levels of productivity, which means that a savvy developer can copy the user experience from an existing SaaS solution without the upfront research investment and at a fraction of the development costs. The developer would create a product with an almost identical value proposition and minimal operation costs in a matter of weeks. Indeed, the developer would not have the reputation of the original product, but the subscription price could be a fraction of the original and still be profitable.

Another step to consider would be to make the product open source. The development would benefit from free community bug fixes and features, and the market would trust the product more as there would be no fear of vendor lock-in. Ultimately, the developer would only charge a small fee for convenience; SaaS product will "become a commodity product". The small footprint of the team and low operation costs would mean that the business has more agility and capacity to innovate than the large business.

SaaS products will transition from a high-margin to a low-margin model. As new market leaders emerge, the low margins will deter new competitors, setting up the new business for long-term success. The model might is not great incentive for investors, but it will undoubtedly disrupt the existing SaaS businesses and make the the founders wealthy.

What can SaaS businesses do to avoid disruption?

First, we know that SaaS business valuations have been using crazy multiples for a long time. The extremely high valuations are not a very good starting point. The first step would be dramatically reducing operating costs and transitioning from high growth into profitability so you can reduce your margins as time goes by. The business's ultimate goal should be to charge for convenience, not a product. It would be best if the company ultimately considered open-sourcing the product.

Another thing that the business should consider is to leverage the data from the existing large numbers of customers and embrace AI as soon as possible. Certain AI features require vast amounts of data and can sometimes be patented. The lack of data and the patents could protect the business against disruption from new market entrants.

What do you think? Is this too far-fetched? It won't happen overnight, but time will tell; we should find out in the next 10-15 years.

Thanks for reading!

The key to scaling your business

Remo H. Jansen — Thu, 01 Dec 2022 00:26:57 +0000

The concept of scaling a business is often used interchangeably with growing a business, but these are two distinct concepts. Take successful startups or new small businesses: Without a clear definition of scaling a business, we mistakenly think of these companies as successful because they achieved massive growth in a short period of time. The reality is when a company grows too fast; it makes itself vulnerable to a range of problems stemming from not having created a sure foundation to support rapid development. Learning how to scale a business mitigates these risks by ensuring that foundational operations are created that will support growth in the long term.

LEARNING HOW TO SCALE A BUSINESS

What is scaling in business? To create a working definition of scaling a business, first, consider what it means to start and grow a business. You started your company to fill a need in your market, make a profit and likely fulfil a dream. You need to grow your business to keep it profitable and expand your market reach. Many people think of business expansion as “hockey stick growth,” where there is an initial period of linear growth. Still, once the business hits an inflexion point, revenue shoots up sharply.

As alluring as rapid growth can be, entrepreneurs often place their focus on achieving it right away and lose focus on what matters. The problem with that sort of tunnel vision is that it diminishes the importance of the period of linear growth that comes before the rising handle of the hockey stick – that is, the blade. The blade typically lasts about three to four years, and it is where the most important work is being done.

Scaling a business means utilizing this “blade period” to put systems and procedures into place that will prepare you for lasting, profitable development. The blade period is where you establish your core values, your company culture and your brand identity. It’s also where you will develop the client experience you want to provide and create the initial business model when you take your product or service to market. In short, it’s the make-or-break period of any business.

Scaling a business is not easy to do, which is why it should be done as thoughtfully and meticulously as possible. Because in the long run, when you do hit that surging growth curve, you need as solid of a foundation as possible to hold you up. Here are the most important things to remember when figuring out how to scale a business mindfully.

TIPS FOR HOW TO SCALE A BUSINESS

When we talk about scaling a business, we’re referring to strategies for growth that align with your original business vision while managing the impact of growth on your company. Implementing the following tips for how to scale a business form a sustainable scaling strategy you can rely on.

1. KNOW YOUR PURPOSE

Scaling a business is reliant on creating customer loyalty. What is the best way to create customer loyalty? Focus on employee loyalty first so they can spread the word and pass their enthusiasm for your company on to those they serve. Employees are loyal to companies whose purpose and values align with their own, so they can feel their careers have a higher purpose. Learning how to scale a business will ultimately fail if you don’t first start with your “why” of going into business in the first place. Knowing your purpose and successfully communicating that to your team is how to make them raving fans of your company and organically drive growth.

2. DEVELOP A BUSINESS MAP

Most entrepreneurs have a business plan, but have you thought about developing a business map? Business maps are an effective, comprehensive way to scale a business and meet its goals. Creating a business map prompts you to ask foundational questions such as: What business are you really in? What was your reason for getting into this business in the first place?

Business maps encourage and challenge you to look at where you came from, define your purpose for starting this business and look ahead: What’s next for your business, and where does your company ideally end up? Having this sort of documentation of your goals is a crucial part of learning how to scale a business and will be a helpful reference for when times get tough.

3. PERFECT YOUR PRODUCT OR SERVICE

With their focus on massive growth, many business owners forget to ensure that their product or service is solid. They often figure that they will fix it after getting more users or more distribution. However, if you don’t work out the kinks and get rid of the bugs now, they will only get worse when you are scaling a business. This is why learning to scale a business before pursuing growth will save you headaches and money in the long run. The early years of your business is a time to listen to feedback, find issues and improve your offerings until they meet your customers’ expectations. When you focus on creating a product or service that is of excellent quality, many of your growth issues will take care of themselves. Working on the issues in your first version also helps you assume more control when you scale your business because you will have a deeper understanding of what you and your customers want and need your product or service to be.

4. CREATE THOUGHTFUL PROCESSES AND OPERATIONS

How to scale a business doesn’t just involve growing upward and outward – it also means ensuring that your internal processes and operations are functioning seamlessly. The last thing you want is to start losing customers you’ve worked so hard to acquire because some part of your infrastructure is weak. While perfecting processes, keep in mind that some of the systems and processes that work when your company is in its early stages won’t work on a massive scale. This is where adaptability and flexibility come in, as you may need to tweak processes as you grow. Establishing a framework of what works and keeps your business running smoothly in the early years is key to scaling a business because it forms a solid core. While you can always improve on this core as growth occurs, it’s much more difficult to go back and create it once you’ve grown past a certain level.

5. ESTABLISH YOUR TEAM

It may seem obvious that establishing a strong team is a prerequisite for scaling a business – you can’t handle everything on your own. Developing a management team that is flexible and can grow with the company is an important component when it comes to learning how to scale a business.

Your team is not just about your employees, though. To master how to scale a business sustainably, you must work on developing external relationships with suppliers, partners and other outside organizations that will be part of your overall growth.

One of the best things about operating a small business is the ability to establish intimate relationships with your customers. You get to give them the experience that you want from beginning to end. And the goal should always be to create a raving fan – someone who will be a staunch advocate for your brand and help you scale your business by spreading the word.

Remember, the community that you create around your business can bolster your foundation so that you have even more strength and leverage as you grow. Having a solid network is so important it’s part of the definition of scaling a business. So take the time to really build the “team” that will propel you into the future.

6. LEARN WHEN TO DELEGATE

If you’ve built a strong team, you should have enough trust in them to delegate many important tasks so you can work “on” the business instead of “in” it. However, as a business owner, you want to feel like you’re involved in every aspect of your company and will sometimes have a hard time letting go in certain areas. To really learn how to scale a business, you must delegate tasks to those on your team. What are you doing that someone else could handle?

Don’t trade your time for dollars. Your business has to be able to run itself and thrive even when you’re not there. Do this by addressing limiting beliefs such as “If I want something done right, I have to do it myself” and by establishing delegation habits that allow you to own your time.

7. BUILD YOUR BRAND

Scaling a business requires learning who you are as a company and what you offer your customers. How do you compare to the competition? What do you have that no one else does? What are your biggest weaknesses? What makes you so powerful? What is your message? How do you disrupt your industry?

It could take years to answer these questions, but you can at least start with a basic framework and build from there. Smaller businesses have the benefit of being able to shift gears more readily than larger corporations. So if there is a need for a new approach, use that as an opportunity to innovate and adapt.

Remember, your brand will also set the tone for your company’s culture as you scale your business. It will set the standard for how you make your hires and will help you establish the kind of client experience you want. It will impact marketing, sales and design efforts, and it will influence the kind of company you ultimately become.

8. CONNECT WITH YOUR CUSTOMER

What is scaling in business able to accomplish if it doesn’t also produce loyal customers? Not much. Creating raving fans of your product is critical for your business to thrive amid the ebb and flow of ever-changing consumer preferences. When you’re scaling a business, you’re in an incubation period where there’s room to test approaches to building and maintaining client relationships. This is the time to build client-centered practices into every facet of your business. You want every member of your team to demonstrate empathy, respect and open-mindedness internally so that a collaborative culture of innovation emerges. From there, everyone on staff is able to build rapport with your client, creating connections that will help your product sell itself.

9. WORK ON YOUR NETWORKING SKILLS

“No man is an island,” and this is even more true in the case of entrepreneurs who are scaling a business. You must develop and cultivate a vast network of colleagues, business coaches, resources and mentors who can connect you to the right people and ensure you continue to grow. Attend regular business networking functions in your city or join an industry-related group that offers continuing education and connections to other professionals. Get involved in personal or business coaching and reach out to those who have been in business longer than you to see if they are willing to connect and possibly become your mentor. Scaling a business is not a solitary task. The more people you have on your side, the more successful you will be.

10. PRIORITIZE SUSTAINABILITY

As important as creativity is for any company, running a business is not the place for knee-jerk decisions. Rather than thinking of creativity as a free-for-all tool for solving problems, think of it as a tool for scaling a business. When you prioritize mindful, sustainable growth, you learn to approach challenges thoughtfully so that the solutions you find support your company’s long-term well-being.

11. CONTINUE ADAPTING AND INNOVATING

Scaling a business may seem impossible if you’ve hit a plateau. The truth is, learning how to scale a business is never impossible, but you may need to change what you’re doing if you want to scale successfully. When was the last time your business focused on innovation? When did you last assess what’s holding your company back and tackle those barriers head-on? In business – and in life – if you’re not growing, you’re dying. Don’t change your company just for the sake of change – when you strategically align your choices with your ultimate purpose, scaling your business will come easily. Take the time and do it right. Adopt a winning mindset, but be mindful as you do so. Remember that massive growth is one thing, but it’s sustainable growth that makes for a lasting company.

The first JavaScript conference in Ireland is back!

Remo H. Jansen — Tue, 28 Jun 2022 14:36:18 +0000

JSDayIE is back on September 26th 2023

We are very excited to introduce the second edition of the very first JavaScript conference in Ireland.

JSDayIE 2023 is going to be a day dedicated to the JavaScript community in Ireland. After the COVID pandemic, the goal of the event is to bring together the JavaScript community for one day and showcase some of the best and most innovative work done by the members of the JavaScript community.

JSDayIE 2023 will take place on September 26th, 2023 at The Round Room at the Mansion House in Dawson Street, right in the heart of Dublin.

JSDayIE is a single-track 1-day tech conference featuring talks from a diverse range of JavaScript-related technical topics. The talks will focus on JavaScript best practices, lessons learned, front-end JavaScript frameworks and libraries like React, Vue, and Angular, Node.js and GraphQL development, JavaScript performance, JavaScript flavours such as TypeScript or Reason ML and emerging technologies such as Web Assembly and Progressive Web Apps.

We are working together with the JavaScript communities in Ireland such as Node.js Dublin, React Dublin, CorkJS, BelfastJS, DublinJS, Dublin TypeScript and many others to ensure that everybody is represented in this event.

We are also taking an active part in promoting inclusivity and openness, not only at our conference but in the design and tech scene overall. We’re working together with communities such as Woman Who Code towards having a diverse lineup of speakers.

Tickets are now available!

This year we are introducing a new remote ticket so everyone can watch the conference from home. We are very excited to share that you can get your remote or in-person ticket now!.

Call for Proposals now open!

We are currently looking for speakers. If you want to give a talk, please visit the call for proposals page to learn how to submit your proposal now!

Sponsoring packages now available!

We are also currently looking for sponsors. Sponsoring JSDayIE is a great way to contribute to the healthy growth of the JavaScript community in Ireland and offers a unique opportunity to expose your brand and find talent specialised in JavaScript technologies in Ireland. If you would like your company to sponsor JSDayIE 2023, please visit the sponsors page.

Subscribe to one of our channels to be notified about future editions and important updates!

Implementing a low code customer support solution powered by Zendesk and Azure Logic Apps

Remo H. Jansen — Mon, 09 Nov 2020 10:04:17 +0000

In this post, we are going to learn how to implement customer support capabilities using a minimal code approach and relying on third party services. There are a lot of situations in which you might need to implement some customer support capabilities. Maybe you are developing your own product, or maybe you are working for a company that needs to improve their operations.

With the arrival of COVID-19, e-commerce has become a major concern for most businesses. Having a good customer support strategy in place is a must these days. Online consumers demand features like online live chat or multi-channel communication and expect high responsiveness from online businesses.

The pandemic has generated unprecedented levels of uncertainty for business and they need to be able to adapt in the shortest time possible. For this reason, we are going to really on third party services and use a minimal code approach. This allows us to dramatically reduce the time to market and development cost. Operational cost is also highly flexible because both Zendesk and Azure can adapt their offerings and prices to our business scale and needs.

Zendesk

The first thing we are going to do is to visit https://www.zendesk.com/ and create an account. I will not document how to do this because Zendesk is very intuitive and it has very good documentation.

After creating the account, you can visit the settings page and visit the channels section to find out your support email:

The format of this email address should be support@yourcompany.zendesk.com. You will need to remember this address because we are going to need it later.

We can then visit the widget section under the channels section to enable the contact form and the web chat features:

If you visit the settings you will be able to find the installation guide:

All you need to do is to add a script tag to your website's source code:

<script id="ze-snippet" src="https://static.zdassets.com/ekr/snippet.js?key=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"></script>

We have enabled the contact form widget which is displayed when there are no customer support agents online:

We have also enabled the live chat widget which is displayed when customer support agents are online:

A little icon will be then displayed on the bottom right of your webpage. When a user clicks on the icon, the contact form or the live chat form will be displayed.

Ideally, we want to have a single point to manage all our customer request. The request may have originated in our website, our email or social media:

Web: We are now ready to manage requests that originated on our website.
Email: Managing email requests can be achieved by enabling email forwarding from one of your company email addresses to your Zendesk email address.
Social media: You can visit the channel settings in Zendesk to connect your social media accounts with Zendesk.
Phone calls. Zendesk also allows you to manage phone calls as customer requests tickets. You can learn more using the Zendesk documentation.

Azure Logic Apps

In most cases, the default Zendesk implementation would be enough to get started. However, in my case, I needed an additional custom contact form:

I needed this form to be highly visible and the bottom right "help" button didn't have enough visibility for me. The webform was implemented using React and Formik.

I wanted to send the request that originated using this form to Zendesk. The easiest solution would be to send an email to the Zendesk support email address. We need to implement an HTTP POST endpoint that takes the form details as JSON and send an email to the Zendesk support email address. I wanted to implement this with as little code as possible and the first thing that came so my mind was to use an Azure function.

Using an Azure function would require us to define an HTTP trigger and the code that sends the email. We would need to manage the permissions so our email server allows us to send an email. This wasn't a massive job but it required me to save the code in a repository, deploy it, etc. It was too much work for something so simple. I wanted to find a better way and that is how I ended up using Azure Logic Apps.

We can visit the Azure portal and create a new Azure Logic App, then use the designer to create the logic rules of our app. The first thing that we need to do is to define an HTTP trigger for our HTTP POST request:

You can paste an example of the body of your request and the Logic App designer will automatically translate it into the request schema.

When you save your logic, Azure will generate an URL that you can invoke from your app.

The second thing that we need to do is to add a step:

We need to add a step that will return an HTTP response:

We then need to add a parallel step to send an email. In my case I use Gmail but there are other integrations available.

We need to extract the data from the original HTTP request to add it to the email contents. We can do this using an expression:

We can use triggerBody() to access the request body and json(triggerBody()) to transform it into JSON. We can then access the properties in the request body as follows json(triggerBody()).company.

We can then save everything and two resources should have been created:

We can then invoke the HTTP trigger in our logic app by sending an HTTP request from the web app:

const response = await fetch(`INSERT_THE_TRIGGER_URL_HERE`, {
    method: "POST",
    body: JSON.stringify(values),
});
const json = response.json();

You can then use the browser developer tools to see if the request was successful:

And finally, head to the Azure Logic App monitoring section to see if all the steps worked as expected. The monitoring tools with providing you with some details if something fails:

If everything worked you should now have a new ticket in your Zendesk customer support dashboard:

The operational cost of running this logic app is almost zero and we can get started with Zendesk for just $60 a year. We can now deliver a professional customer support experience on a budget and in just a few hours!

As we can see Azure Logic apps can help us to solve real-business needs with almost no code. This allows us to move faster and adapt faster in a time of unprecedented uncertainty.

Automated refactoring for TypeScript apps with Tsmod

Remo H. Jansen — Mon, 30 Sep 2019 12:29:54 +0000

Inspired by the talk from Cristina Bernardis about jscodeshift at JSDayIE I have released Tsmod.

A library that allows us to write automated refactoring code modifications powered by David Sherret's ts-morph.

What is this about?

If you have a very large codebase and you want to change something across many files this tool will allow you to write a script that will do the work for you. This is a good idea because it can save you time but also because it can be used by other members of the team as a valuable source of information. The transform scripts can also be shared online as open source. A common example is a migration script for a breaking change in the API of a framework. You can release the new version of the framework together with the transform scripts to help the users of the framework to upgrade their version with ease.

Installation

You can install this module as a global dependency using npm:

npm install -g tsmod

Please note that if you have never used TypeScript or ts-node you will also need them:

npm install -g typescript ts-node

The typescript module is the TypeScript compiler and the ts-node module is a version of Node.js that can work directly with TypeScript files (.ts) instead of using JavaScript files (.js).

Usage

The following command applies the transform var_to_const_tramsform.ts to the files fileA.ts and fileB.ts:

tsmod -t var_to_const_tramsform.ts fileA.ts fileB.ts

Please Note: A TypeScript compiler configuration file (tsconfig.json) file is expected in the current directory when you run the previous command.

Transform example

The transforms are powered by the ts-morph API. You can learn more about the API at https://ts-morph.com.

The following example changes all var variable declarations into const variable declarations:

import { SourceFile, SyntaxKind, VariableDeclarationKind } from "ts-morph";

export const varToConstTransform = (file: SourceFile, transformArgs: {}) => {
  // Find all variable declarations in source file
  const variableStatements = file.getDescendantsOfKind(
    SyntaxKind.VariableStatement
  );
  // Change var for const for each statement
  variableStatements.forEach(variableStatement => {
    const declarationKind = variableStatement.getDeclarationKind();
    if (declarationKind === VariableDeclarationKind.Var) {
      variableStatement.setDeclarationKind(VariableDeclarationKind.Const);
    }
  });
  // Return source code
  const updatedSourceCode = file.getText();
  return updatedSourceCode;
};

Options

For additional help use the following:

tsmod -h

I hope you enjoyed it, please let me know your thoughts!

Please note that at the moment this project is just an experiment is not considered a mature piece of software...

5 JavaScript conferences to attend before the end of 2019

Remo H. Jansen — Thu, 25 Jul 2019 14:06:50 +0000

Now that many of us have finished our holidays and we are back in work we have started to plan how to stay up to date and up-skill for the rest of the year. Here are 5 conferences to attend before the end of 2019!

JSConf US (US, August)

JSConf US has pushed the JavaScript outside of its comfort zone, the web browser, and into the forefront of servers, drones, robots, and video games.

The "Choose Your Own Adventure" day is what sets JSConf US apart from other conferences. It provides you with an extraordinary opportunity to socialize with the brightest minds in our community in a new and different environment. JSConf US has IoT workshops like NodeBots and NodeBoats for those that want to learn how to program the physical world and Surfing lessons or a trip to the San Diego Zoo Safari Park for those that want to step away from the computer and go outside!

Early bird tickets start at 850 USD. You can learn more about this event and get your tickets at https://2019.jsconf.us/.

JSDayIE (Ireland, September)

JSDayIE 2019 is a 1-day single-track tech conference dedicated to the JavaScript community in Ireland featuring over 450 attendees and some of the best JavaScript professionals and organizations in Ireland.

JSDayIE is the first JavaScript conference in Ireland and will take place in 2019, on September 20th at The Round Room at the Mansion House in Dawson Street, Dublin.

The Dev.to community members can access a 15% discount here.

Early bird tickets start at 116 EUR. You can learn more about this event and get your tickets at https://www.jsday.org/.

TsConf (US, October)

The first conference ever focused completely on TypeScript! Beyond the typical introduction to TypeScript talk, at TsConf you will spend the day discussing best practices and advanced features of the language, including information from key members of the TypeScript team. All in an informal and fun environment!

Last year’s TSconf speaker line-up rocked. Introductory topics take a backseat at this conference where we put expert JavaScript engineers at the wheel to steer us deep into the land of TypeScript.

Early bird tickets start at 350 USD. You can learn more about this event and get your tickets at https://tsconf.io/.

NodeConf EU (Ireland, November)

NodeConf EU is the key Node.js event in Europe, providing a forum for the Node.js community, the conference has become legendary in the Node community for all the right reasons. Over the course of a few days each year, some of the key people in Node join together in Ireland at the conference to celebrate Node. It's a place where you will find some of the best speakers and experts on the subject of Node, Discussions about collaboration, and about becoming contributors to the Node product.

Early bird tickets start at 799 EUR. You can learn more about this event and get your tickets at https://www.nodeconf.eu/.

DotJS (Paris, December)

DotJS is coming back in 2019 and for the first time, it will be a 2-day conference!

Day 1 will be all about Frontend development (UI frameworks, browsers, ...). Day 2 will be about Backend development and JavaScript as a language (Node.js, ES2019, compilers, ...).

DotJS 2019 will continue inviting the best and brightest hackers in the community to explore new horizons. You can expect a few surprises & more than 1400 new friends to make!

Early bird tickets start at 499 EUR. You can learn more about this event and get your tickets at https://www.dotjs.io/.

JSDayIE 2019 CFP now open!

Remo H. Jansen — Fri, 01 Mar 2019 10:03:25 +0000

The JSDayIE 2019 CFP is now open! We’re excited to welcome the JavaScript community to submit talks for JSDayIE 2019 that will take place on September 20th 2019. The Call for Proposals closes on April 15th, 2019.

We are looking for a multitude of topics and perspectives but most of all we value:

Original topics, presented for the first time
Practical ideas that attendees can apply at work the next day
Trends and hot topics which are relevant in 2019 and beyond
Fresh perspectives on the JS ecosystem

We don't have a specific theme for JSDayIE. Instead, we’re aiming to select talks that are interesting for as many JavaScript developers as possible. Our audience skill level is intermediate to advanced.

All talks should be in English and 25 minutes long. We will be on a tight schedule and will enforce the time limits rigorously. We suggest that you time your presentation accordingly in advance.

We can help

Not everyone is a natural-born talent on stage. Not everyone can produce kick-ass slide decks. Not everyone is a live-demo master. Not everyone knows they have something great to talk about.

There are about a million reasons why you may not consider yourself a speaker. We are here to prove you wrong. If all you have is a gut feeling that you should be on stage, we are here to help you develop or hone the skills you think you lack to deliver a great presentation.

We are committed to fulfilling our mission as a community event. We are all community people and we want to be as close to you as possible. We will try to be supportive and helpful and we will do our best to get back to you with valuable feedback from the CFP process. In case you wish to talk with someone from the team, do not hesitate to write an email at hello@jsday.org (just please don’t use this email to submit a proposal).

Please visit the official CFP guidelines page if you need additional help.

Good luck!

Introducing JSDayIE 2019!

Remo H. Jansen — Fri, 01 Mar 2019 09:51:00 +0000

Welcome to the official announcement of JSDayIE 2019! We are very excited to introduce the very first JavaScript conference in Ireland.

JSDayIE 2019 is going to be a day dedicated to the JavaScript community in Ireland with over 450 attendees. The goal of the event is to bring together the JavaScript community for one day and showcase some of the best and most innovative work done by the members of the JavaScript community in Ireland.

JSDayIE is presented by Wolk Software. Wolk Software is an Ireland based startup dedicated to empowering developers and teams to achieve their best through consultancy and training services and technical publications and events.

JSDayIE 2019 will take place on September 20th, 2019 at The Round Room at the Mansion House in Dawson Street, right in the heart of Dublin.

We are currently looking for speakers. If you want to give a talk, Please visit the call for proposals page to learn how to submit your proposal now!

We are also currently looking for sponsors. Sponsoring JSDayIE is a great way to contribute to the healthy growth of the JavaScript community in Ireland and offers a unique opportunity to expose your brand and find talent specialized in JavaScript technologies in Ireland. If you would like your company to sponsor JSDayIE 2019, please visit the sponsors page.

The tickets will be available very soon! Subscribe to our Newsletter or follow us on Twitter, Facebook or LinkedIn to be notified when the tickets become available and other important updates!

Logo credits: The JSDayIE 2019 logo is based on the Dublin logo design by Kieran Sheehan and it is licensed under the Creative Commons Attribution-NoDerivatives license.

Why TypeScript is a better option than JavaScript when it comes to functional programming?

Remo H. Jansen — Wed, 30 Jan 2019 15:47:10 +0000

In this post, I would like to discuss the importance of static types in functional programming languages and why TypeScript is a better option than JavaScript when it comes to functional programming due to the lack of a static type system in JavaScript.

Life without types in a functional programming code base

Please try to put your mind on a hypothetical situation so we can showcase the value of static types. Let's imagine that you are writing some code for an elections-related application. You just joined the team, and the application is quite big. You need to write a new feature, and one of the requirements is to ensure that the user of the application is eligible to vote in the elections. One of the older members of the team has pointed out to us that some of the code that we need is already implemented in a module named @domain/elections and that we can import it as follows:

import { isEligibleToVote } from "@domain/elections";

The import is a great starting point, and We feel grateful for the help provided by or workmate. It is time to get some work done. However, we have a problem. We don't know how to use isEligibleToVote. If we try to guess the type of isEligibleToVote by its name, we could assume that it is most likely a function, but we don't know what arguments should be provided to it:

isEligibleToVote(????);

We are not afraid about reading someoneelses code do we open the source code of the source code of the @domain/elections module and we encounter the following:

const either = (f, g) => arg => f(arg) || g(arg);
const both = (f, g) => arg => f(arg) && g(arg);
const OUR_COUNTRY = "Ireland";
const wasBornInCountry = person => person.birthCountry === OUR_COUNTRY;
const wasNaturalized = person => Boolean(person.naturalizationDate);
const isOver18 = person => person.age >= 18;
const isCitizen = either(wasBornInCountry, wasNaturalized);
export const isEligibleToVote = both(isOver18, isCitizen);

The preceding code snippet uses a functional programming style. The isEligibleToVote performs a series of checks:

The person must be over 10
The person must be a citizen
To be a citizen, the person must be born in the country or naturalized

We need to start doing some reverse engineering in our brain to be able to decode the preceding code. I was almost sure that isEligibleToVote is a function, but now I have some doubts because I don't see the function keyword or arrow functions (=>) in its declaration:

const isEligibleToVote = both(isOver18, isCitizen);

TO be able to know what is it we need to examine what is the both function doing. I can see that both takes two arguments f and g and I can see that they are function because they are invoked f(arg) and g(arg). The both function returns a function arg => f(arg) && g(arg) that takes an argument named args and its shape is totally unknown for us at this point:

const both = (f, g) => arg => f(arg) && g(arg);

Now we can return to the isEligibleToVote function and try to examine again to see if we can find something new. We now know that isEligibleToVote is the function returned by the both function arg => f(arg) && g(arg) and we also know that f is isOver18 and g is isCitizen so isEligibleToVote is doing something similar to the following:

const isEligibleToVote = arg => isOver18(arg) && isCitizen(arg);

We still need to find out what is the argument arg. We can examine the isOver18 and isCitizen functions to find some details.

const isOver18 = person => person.age >= 18;

This piece of information is instrumental. Now we know that isOver18 expects an argument named person and that it is an object with a property named age we can also guess by the comparison person.age >= 18 that age is a number.

Lets take a look to the isCitizen function as well:

const isCitizen = either(wasBornInCountry, wasNaturalized);

We our out of luck here and we need to examine the either, wasBornInCountry and wasNaturalized functions:

const either = (f, g) => arg => f(arg) || g(arg);
const OUR_COUNTRY = "Ireland";
const wasBornInCountry = person => person.birthCountry === OUR_COUNTRY;
const wasNaturalized = person => Boolean(person.naturalizationDate);

Both the wasBornInCountry and wasNaturalized expect an argument named person and now we have discovered new properties:

The birthCountry property seems to be a string
The naturalizationDate property seems to be date or null

The either function pass an argument to both wasBornInCountry and wasNaturalized which means that arg must be a person. It took a lot of cognitive effort, and we feel tired but now we know that we can use the isElegibleToVote function can be used as follows:

isEligibleToVote({
    age: 27,
    birthCountry: "Ireland",
    naturalizationDate: null
});

We could overcome some of these problems using documentation such as JSDoc. However, that means more work and the documentation can get outdated quickly.

TypeScript can help to validate our JSDoc annotations are up to date with our code base. However, if we are going to do that, why not adopt TypeScript in the first place?

Life with types in a functional programming code base

Now that we know how difficult is to work in a functional programming code base without types we are going to take a look to how it feels like to work on a functional programming code base with static types. We are going to go back to the same starting point, we have joined a company, and one of our workmates has pointed us to the @domain/elections module. However, this time we are in a parallel universe and the code base is statically typed.

import { isEligibleToVote } from "@domain/elections";

We don't know if isEligibleToVote is function. However, this time we can do much more than guessing. We can use our IDE to hover over the isEligibleToVote variable to confirm that it is a function:

We can then try to invoke the isEligibleToVote function, and our IDE will let us know that we need to pass an object of type Person as an argument:

If we try to pass an object literal our IDE will show as all the properties and of the Person type together with their types:

That's it! No thinking or documentation required! All thanks to the TypeScript type system.

The following code snippet contains the type-safe version of the @domain/elections module:

interface Person {
    birthCountry: string;
    naturalizationDate: Date | null;
    age: number;
}

const either = <T1>(
   f: (a: T1) => boolean,
   g: (a: T1) => boolean
) => (arg: T1) => f(arg) || g(arg);

const both = <T1>(
   f: (a: T1) => boolean,
   g: (a: T1) => boolean
) => (arg: T1) => f(arg) && g(arg);

const OUR_COUNTRY = "Ireland";
const wasBornInCountry = (person: Person) => person.birthCountry === OUR_COUNTRY;
const wasNaturalized = (person: Person) => Boolean(person.naturalizationDate);
const isOver18 = (person: Person) => person.age >= 18;
const isCitizen = either(wasBornInCountry, wasNaturalized);
export const isEligibleToVote = both(isOver18, isCitizen);

Adding type annotations can take a little bit of additional type, but the benefits will undoubtedly pay off. Our code will be less prone to errors, it will be self-documented, and our team members will be much more productive because they will spend less time trying to understand the pre-existing code.

The universal UX principle Don't Make Me Think can also bring great improvements to our code. Remember that at the end of the day we spend much more time reading than writing code.

About types in functional programming languages

Functional programming languages don't have to be statically typed. However, functional programming languages tend to be statically typed. According to Wikipedia, this tendency has been rinsing since the 1970s:

Since the development of Hindley–Milner type inference in the 1970s, functional programming languages have tended to use typed lambda calculus, rejecting all invalid programs at compilation time and risking false positive errors, as opposed to the untyped lambda calculus, that accepts all valid programs at compilation time and risks false negative errors, used in Lisp and its variants (such as Scheme), though they reject all invalid programs at runtime, when the information is enough to not reject valid programs. The use of algebraic datatypes makes manipulation of complex data structures convenient; the presence of strong compile-time type checking makes programs more reliable in absence of other reliability techniques like test-driven development, while type inference frees the programmer from the need to manually declare types to the compiler in most cases.

Let's consider an object-oriented implementation of the isEligibleToVote feature without types:

const OUR_COUNTRY = "Ireland";

export class Person {
    constructor(birthCountry, age, naturalizationDate) {
        this._birthCountry = birthCountry;
        this._age = age;
        this._naturalizationDate = naturalizationDate;
    }
    _wasBornInCountry() {
        return this._birthCountry === OUR_COUNTRY;
    }
    _wasNaturalized() {
        return Boolean(this._naturalizationDate);
    }
    _isOver18() {
        return this._age >= 18;
    }
    _isCitizen() {
        return this._wasBornInCountry() || this._wasNaturalized();
    }
    isEligibleToVote() {
        return this._isOver18() && this._isCitizen();
    }
}

Figuring this out how the preceding code should be invoked is not a trivial task:

import { Person } from "@domain/elections";

new Person("Ireland", 27, null).isEligibleToVote();

Once more, without types, we are forced to take a look at the implementation details.

constructor(birthCountry, age, naturalizationDate) {
    this._birthCountry = birthCountry;
    this._age = age;
    this._naturalizationDate = naturalizationDate;
}

When we use static types things become easier:

const OUR_COUNTRY = "Ireland";

class Person {

    private readonly _birthCountry: string;
    private readonly _naturalizationDate: Date | null;
    private readonly _age: number;

    public constructor(
        birthCountry: string,
        age: number,
        naturalizationDate: Date | null
    ) {
        this._birthCountry = birthCountry;
        this._age = age;
        this._naturalizationDate = naturalizationDate;
    }

    private _wasBornInCountry() {
        return this._birthCountry === OUR_COUNTRY;
    }

    private _wasNaturalized() {
        return Boolean(this._naturalizationDate);
    }

    private _isOver18() {
        return this._age >= 18;
    }

    private _isCitizen() {
        return this._wasBornInCountry() || this._wasNaturalized();
    }

    public isEligibleToVote() {
        return this._isOver18() && this._isCitizen();
    }

}

The constructor tells us how many arguments are needed and the expected types of each of the arguments:

public constructor(
    birthCountry: string,
    age: number,
    naturalizationDate: Date | null
) {
    this._birthCountry = birthCountry;
    this._age = age;
    this._naturalizationDate = naturalizationDate;
}

I personally think that functional programming is usually harder to reverse-engineering than object-oriented programming. Maybe this is due to my object-oriented background. However, whatever the reason I'm sure about one thing: Types really make my life easier, and their benefits are even more noticeable when I'm working on a functional programming code base.

Summary

Static types are a valuable source of information. Since we spend much more time reading code than writing code, we should optimize our workflow so we can be more efficient reading code rather than more efficient writing code. Types can help us to remove a great amount of cognitive effort so we can focus on the business problem that we are trying to solve.

While all of this is true in object-oriented programming code bases the benefits are even more noticeable in functional programming code bases and this exactly why I like to argue that TypeScript is a better option than JavaScript when it comes to functional programming. What do you think?

If you have enjoyed this post and you are interested in Functional Programming or TypeScript, please check out my upcoming book Hands-On Functional Programming with TypeScript