DEV Community: Alvaro (Blag) Tejada Galindo

Introducing Frankie — The Programming Language — “It’s alive!” 🧟⚡

Alvaro (Blag) Tejada Galindo — Wed, 18 Mar 2026 17:06:19 +0000

You might or might not, but I like to call myself a Programming Languages Archaeologist, mainly because I like to find and learn old programming languages that most likely nobody uses in modern day 🤓 But I also like learning about brand new programming languages.

If you haven't read it already, I have a nice and ongoing series named Exploring Programming Languages, where I develop the same code in multiple programming languages. Currently, there are more than 60 🥹

But anyway, let's talk about Frankie - The Programming Language 🧟‍♂️

So I teamed up with Anthropic's Claude, and together we created, coded, vibe coded, whatever, a programming language which by definition is:

Stitched together from Ruby • Python • R • Fortran

Why? Because those 4 are my favourite programming languages 😅

The foundation is Python, while the syntax is Ruby-like with commands that come from R and Fortran, besides obviously Ruby and Python.

Frankie is an interpreted language that can be compiled to Python source code.

Here are some features of the language:

Stitched from four languages - Ruby's expressive syntax, Python's clean semantics, R's statistics and pipe operator (|>), and Fortran's do...while and integer division (//)
Proudly procedural - functions, data, loops, and logic. No classes, no self, no inheritance
Built-in statistics - mean(), stdev(), median(), min(), max(), and more, operating natively on vectors
R-style pipe operator - chain calls cleanly with |>, e.g. data |> sum |> puts
Ruby-style iterators - .each, .map, .select with do |x| ... end blocks
String interpolation - "Hello, #{name}!" just like Ruby
Error handling - begin / rescue / ensure blocks with raise
Built-in SQLite - zero-dependency database access via db_open, db.insert, db.find_all, etc.
v1.3 extras - JSON, CSV, DateTime, and HTTP support out of the box
Zero dependencies - runs on Python 3.10+, nothing else to install

If you're curious, here's the GitHub repo 😇. I would appreciate a couple of stars if possible 😉 I will try to improve Frankie as much as possible.

Here's a small sample so you know what to expect 😁

# Fibonacci
def fib(n)
  if n <= 1
    return n
  end
  return fib(n - 1) + fib(n - 2)
end

puts fib(10)    # 55

# R-style stats
data = [23, 45, 12, 67, 34, 89]
puts mean(data)
puts stdev(data)
data |> sum |> puts

# Iterators
evens = [1,2,3,4,5,6].select do |x|
  x % 2 == 0
end
puts evens    # [2, 4, 6]

# Case/when
case evens.length
when 3
  puts "three evens"
else
  puts "something else"
end

# Destructuring
lo, hi = [min(data), max(data)]
puts "Range: #{lo}..#{hi}"

# Error handling
begin
  raise "oops" if lo < 0
rescue e
  puts "Caught: #{e}"
end

That's it for now. I hope you give Frankie some love and see you on the next Frankie release 🤩

7 SDK Generator Tools for APIs in 2025

Alvaro (Blag) Tejada Galindo — Thu, 16 Jan 2025 03:44:27 +0000

As developers, we constantly seek ways to streamline our workflows and improve efficiency. One tool that’s gained traction in recent years is the SDK generator. These tools automate the creation of software development kits (SDKs) for APIs, simplifying the process of integrating external services into applications. In this post, we’ll dive into the world of SDK generator tools, examining their features, benefits, and how they can save valuable time for developers working with APIs.

These tools can help you:

Grow the number of developers building with your API.
Shorten the time to go live aka “time to 200”.
Reduce the number of support requests from developers.

What’s on our agenda?

What is an SDK Generator tool?
Why would you need one?
How can we test them?
My final verdict
Let’s analyze the available options
- APIMatic
- OpenAPI-Generator
- Fern
- Stainless
- Speakeasy
- Kiota
- AutoRest
Conclusion

What is an SDK Generator tool

When I think about software development, problem-solving and creating something new excites me. When designing scalable systems, optimizing performance, and crafting elegant solutions.

But in reality, when connecting two software systems, the work can feel more repetitive than rewarding. Especially when working with HTTP APIs and sending JSON over the wire. This is where Software Development Kits (SDKs), the unsung heroes of modern web development, come in. SDKs are pre-written code, instructions, and reference documentation that help a dev build an integration faster and more reliably. This leads to a faster time to go live and less ongoing maintenance.

When creating an SDK, there are three options:

Write it manually. (Customizable, high quality, high cost, expensive to maintain)
Use an open-source generator. (No cost, lower quality, requires an engineer to augment with custom scripts, no support)
Use an SDK vendor. (Highest quality, can be offered instantly, Slack-based support, requires paid subscription)

Why It Matters

Efficiency: Faster development with less boilerplate.
Consistency: Standardized, easy-to-maintain SDKs.
Empowerment: Developers can focus on building features, not handling low-level integrations.

SDK generators are a smarter way to streamline development, improve scalability, and boost developer satisfaction.

Why would you need one

The need for an SDK generator tool arises when efficiency, consistency, and scalability become priorities. If your team manages APIs or services that require integration across multiple platforms or programming languages, creating SDKs manually can be time-consuming and prone to errors. An SDK generator eliminates this bottleneck by providing:

Time Savings: Automating SDK creation frees up developers to focus on more critical tasks, such as improving core functionality or enhancing user experience.
Consistency: Generated SDKs follow the same patterns and conventions, reducing the likelihood of inconsistencies across different language implementations.
Scalability: As your platform evolves or new APIs are introduced, updating SDKs becomes a straightforward process, ensuring your integrations remain up-to-date without significant overhead.
Developer Enablement: By offering prebuilt SDKs, you make it easier for external developers or clients to integrate with your platform, fostering a stronger and more productive developer community.

An SDK generator tool is about efficiency, scalability, and developer happiness. It’s not just a shortcut; it’s a smarter way to approach software development. So, if you’re managing APIs or developing platforms that others need to integrate with, it’s worth exploring how SDK generators can elevate your development game.

How can we test them

Not too long ago, I had the opportunity to write a blog post for my friends at Zuplo titled How to Build an API with Ruby and Sinatra. In that post, I walked through the process of building a straightforward yet functional API using Ruby and the lightweight Sinatra framework. The goal was to show just how accessible API development can be, even for those who might be new to it.

What made the process even more exciting was incorporating ChatGPT into the workflow. After building the API, I used ChatGPT to generate a complete OpenAPI Specification — a task that would have otherwise required a fair amount of manual effort and attention to detail. With just a bit of guidance, ChatGPT produced a spec that was not only accurate but ready to use, saving me valuable time.

But the story doesn’t end there. That very OpenAPI Specification is now pulling double duty: it’s becoming the foundation for something even more practical. We’ll use it to test and compare a range of SDK generator tools to see how they perform and what they bring to the table. This process will shine a light on just how much these tools can simplify development by transforming API specs into ready-to-use SDKs in various programming languages. So stay tuned as we put these tools through their paces and explore the possibilities they offer for making integration faster and easier than ever.

My Final Verdict

After trying all these tools, two stand out: Fern and APIMatic. Both deliver an excellent user experience, great SDK production, and clear documentation, despite having completely different approaches. Since I value both the SDKs and documentation equally, I’d choose Fern for its SDKs because the code quality is clean, well-structured, and feels the most hand-written — it’s idiomatic and typesafe by default. Feel free to reach out with any questions or comments! I plan to update this article in 2026.

Let analyze the available options

APIMatic

Maximize API Adoption by Speaking Your Developers Language!

Multi-Language SDK Generation → It supports JavaScript, Python, Ruby, PHP, C#, Java, TypeScript, Objective-C, Go, and Dart. Support for Swift is coming soon.
Analytics and Insights → Offers usage analytics for SDKs and API documentation, giving insights into how developers are using your APIs.
API Mocking → Provides mock servers for testing and simulating API responses without hitting live endpoints.
Developer Experience → Provides a developer portal for easy access to SDKs, API documentation, and other resources.
API Transformations → Converts API descriptions between multiple formats (OpenAPI (Swagger), RAML, API Blueprint, Postman Collections, HAR (HTTP Archive), and more).

APIMatic has an interesting requirement for registration: you need a business email address to sign up. However, I reached out to support, and they kindly provided me with a test user, so we’ll be able to discuss it.

When we log into APIMatic, we’re greeted with two options for creating our SDK: either by describing the API manually or by importing an OpenAPI Specification. For simplicity and efficiency, we’re going to go with the second option — importing an OpenAPI Spec. This allows us to leverage an existing API definition to streamline the SDK generation process. Let’s dive in and get started!

Importing our OpenAPI Spec

Next, we need to provide APIMatic with our OpenAPI Specification. There are two ways to do this:

Upload the OpenAPI Spec directly from our local system.
Provide the URL where the file is hosted.

For this guide, we’ll go with the first option and upload the OpenAPI Spec directly. This straightforward approach ensures that APIMatic has everything it needs to generate the SDK efficiently. Let’s proceed with the upload and move on to the next step!

OpenAPI Spec selected

Once the OpenAPI Spec is uploaded, APIMatic provides a helpful logging summary. This summary gives you a clear overview of the import process, highlighting any errors or warnings that may need our attention.

It’s a great way to ensure that our API definition is in good shape before moving forward. If there are issues, we can address them right away, saving time and avoiding problems down the line. With everything in order, we’re ready to move on to the SDK generation!

Errors, Warning and Messages on our OpenAPI Spec

Once everything is processed, APIMatic generates two key resources for us:

The API Portal: This is the comprehensive documentation for your API, neatly organized and ready to be explored.
The SDK: The actual code for our SDK, which you can choose to either download for local use or publish, making it available for others to access and download.

For this guide, we’re going to take a closer look at the API Portal to review the documentation and ensure everything looks good. After that, we’ll download the SDK so we can test it locally on our machine. Let’s start by exploring the API Portal and see how the documentation turned out!

Generation of SDK and Documentation

The API Portal generated by APIMatic is impressively well-crafted. It provides a clear and organized list of all the API endpoints and models, making it easy to navigate and understand our API’s structure.

One standout feature is the ability to choose the programming language for the SDK. APIMatic generates SDKs for multiple languages, and you can simply download the one you need — this flexibility is incredibly convenient for developers working in different tech stacks.

Additionally, the portal offers options to either publish or customize it. The ability to tailor the portal to our brand or specific requirements adds significant value, especially if you plan to share it with external developers or stakeholders.

Another thoughtful addition is the step-by-step tutorial embedded in the portal. This guide helps users get up to speed quickly, making the onboarding experience smoother and more intuitive. Overall, it’s a great combination of functionality and user experience!

Generated API Portal (Documentation)

When it comes to customizing the API Portal, APIMatic offers a high level of flexibility — we can change just about everything. From the design and layout to the branding elements like logos, colors, and fonts, you have full control to tailor the portal to match our organization’s style and requirements.

Personalization of API Portal

Let’s proceed by downloading the Python SDK to see how it performs. Once downloaded, we’ll take a closer look at the generated code to evaluate its structure, functionality, and ease of use. After that, we can run some tests to explore how it behaves in a real-world scenario. Let’s dive in and put the SDK to the test!

Selection an SDK Language

We selected Python as the target language and downloaded the SDK, which comes packaged neatly in a .zip file. Once the download is complete, we can extract the files to review the generated code and folder structure. From there, we’ll set up our environment and start experimenting with the SDK to see how well it integrates and performs.

SDK Generated in a .zip file

Once the SDK is unzipped and placed into our working directory, the next step is to set it up locally. This involves installing the dependencies, building the package, and then installing it. Open the terminal and run the following commands:

Install the required dependencies:

pip3 install -r requirements.txt

Build the SDK package using Poetry:

poetry build

Install the generated package locally:

pip3 install dist/dunequotesapi-1.0.0-py3-none-any.whl

With the SDK installed, we’re ready to create a test script to put it through its paces. Here’s an example script you can use to test the functionality of the generated SDK:

from dunequotesapi.dunequotesapi_client import DunequotesapiClient

client = DunequotesapiClient()

quotes = client.client.get_quotes()

for quote in quotes:
    print(f'#{quote.character} ==> #{quote.quote}')

OpenAPI Generator

Generate clients, servers, and documentation from OpenAPI 2.0/3.x documents

Multi-Language SDK Generation → Supports over 50 programming languages for SDK and client library generation, including Java, TypeScript, Python, Ruby, PHP, C#, Go, Swift, Kotlin, Dart, JavaScript, and more.
Wide Compatibility → Supports OpenAPI Specification versions 2.0, 3.0, and 3.1, making it compatible with modern API designs.
Community and Open Source → Fully open-source with a large, active community.
Plugins and Ecosystem Support → Integrates well with tools like Swagger Editor, Postman, and API Gateway platforms.
Easy Integration with CI/CD → Easily integrates into CI/CD pipelines to ensure SDKs and server stubs are automatically updated with API changes.

First things first, we need to get the OpenAPI-Generator CLI installed. While there are many ways to install it, I prefer using Homebrew for its simplicity. Run the following command to get started:

brew install openapi-generator

With the CLI installed, the next step is to generate the SDK. In this case, we’ll target Ruby. To do so, use the following command:

openapi-generator generate -i DuneQuotesSpec.yaml -g ruby -o /tmp/test/

And just like that, our Ruby SDK is up and running! However, I have to admit that testing the generated SDK wasn’t as smooth as I’d hoped. Browsing through the generated folders and files felt a bit cumbersome. Finding exactly what I needed took more effort than expected, and the naming conventions didn’t quite align with my expectations. This made the process of exploring and testing the SDK more time-consuming than it should have been:

require 'openapi_client'

test = OpenapiClient::DefaultApi.new()
quotes = test.api_v1_quotes_get()

quotes.each{ |quote|
 puts "#{quote.character} ==> #{quote.quote}"
}

OpenAPI Generator — Running the Ruby SDK

You might be wondering how to generate documentation for our API. Luckily, OpenAPI-Generator makes this an incredibly straightforward task. All you need to do is run the following command:

openapi-generator generate -i DuneQuotesSpec.yaml -g html -o docs

This will generate a set of clean, HTML-based documentation for our API and save it to the docs folder. With just one command, you’ll have a professional-looking API reference that’s ready to share with our team or users. Simple and effective!

Generated documentation for the SDK

Fern

Instant SDKs and API Docs

Multi-Language Support → It supports TypeScript, Python, Java, Go, Ruby, PHP, and C#. Support for Swift, Rust, Terraform, and CLI is coming soon.
Seamless API Documentation → Automatically generates developer-friendly API documentation that integrates with your SDKs.
Unified Tooling → Fern combines SDK generation and API documentation into a single platform.
Developer-Focused Experience → Provides a modern, easy-to-use CLI and toolchain that simplifies SDK creation and maintenance.
Focus on CI/CD Integration → Easily integrates into CI/CD pipelines for automated SDK updates when API specifications change.

First things first, we need to get the Fern CLI installed. To do this, run the following command:

npm install -g fern-api

Once installed, the next step is to initialize the Fern folder. Using our OpenAPI specification file, run:

fern init --openapi duneQuotesSpec.yaml

This will set up a working environment for Fern. Now, it’s time to add the language we want to target. In this case, we’ll be generating an SDK for Ruby. To add Ruby as the target language, execute:

fern add fern-ruby-sdk --group SDK

With everything configured, we’re ready to generate the SDK, which was idiomatic, typesafe, and overall perfectly organized and easy to read. Run the following command to kick off the generation process:

fern generate --group SDK

And that’s it! We just generated a Ruby SDK with Fern, using our OpenAPI specification as the foundation.

To put the generated SDK to the test, I created a straightforward file to ensure everything works as expected. This file serves as a basic playground to verify that the SDK functions correctly and interacts seamlessly with the API.

require 'atejada_api_client'

test = AtejadaApiClient::Client.new()
quotes =  test.get_quotes()

quotes.each{ |quote|
 puts "#{quote.character} ==> #{quote.quote}"
}

Fern — Running the Ruby SDK

But what about documentation? After all, an SDK is only as good as its documentation — developers need clear, accessible guidance to make the most of it. Thankfully, Fern makes this process just as simple. To generate documentation, we need to start by initializing the docs folder with the following command:

fern init --docs

Once the folder is set up, generating the documentation is just as straightforward. Run:

fern generate --docs

And that’s it! We now have properly generated documentation to complement our SDK, ensuring developers have all the tools they need to integrate seamlessly with our API.

Generated documentation for the Ruby SDK

Stainless

Generate best-in-class SDKs

SDK Generation → It supports Node/TypeScript, Python, Go, Java, Kotlin, Ruby, and Terraform.
Typed Models and Strong Validation → Generates strongly-typed models to improve reliability and usability in SDKs.
Streamlined Updates → Automates SDK updates whenever API specifications change, ensuring the SDKs stay in sync with the API.
Lightweight and Modern → Stainless is a lightweight, modern tool built for fast-moving teams.
Simplified Authentication → Built-in support for various authentication methods, including OAuth2, API keys, and more.

To generate our SDK, the first step is to provide some essential information and upload our OpenAPI Specification file. This ensures that the tool has everything it needs to create a tailored SDK based on the API’s structure and endpoints. The process is straightforward, and once the details are filled in, you’re ready to kick off the generation!

Stainless sign up page

By default, once the generation process is complete, the tool provides two SDKs ready to use: one for Node.js and another for Python. This makes it easy to get started with two of the most popular programming environments right away, catering to both backend and scripting needs.

Stainless SDK overview page

That said, since we’re aiming to generate a Ruby SDK, the next step is to click on the “Add SDKs” button:

Available languages

I could opt for Go, request Java or Kotlin, but Ruby isn’t available just yet. Not a major issue, though — we can always test our solution using Python.

SDK Generated Private Repo

By heading to the GitHub-generated repo, we can find the installation instructions and testing steps, which will undoubtedly save us a significant amount of work.

from dunequotes import Dunequotes

client = Dunequotes()

quotes = client.quotes.list()

for quote in quotes:
    print(f'#{quote.character} ==> #{quote.quote}')

Stainless generated Python SDK

So, where are the docs? Unfortunately, I couldn’t find them. The GitHub repo points to https://docs.dunequotes.com/, but that path doesn’t exist. I even searched through the entire repo and came up empty-handed.

Speakeasy

The platform to Build APIs your users love

Idiomatic SDK Generation → Generates developer-friendly SDKs in multiple programming languages, such as TypeScript, Python, Go, Java, C#, PHP [beta], Unity [beta], Ruby [alpha], and Swift [alpha]
API Consumer-First Focus → Speakeasy is built with API consumers in mind, ensuring the SDKs are easy to use, maintain, and integrate into existing projects.
Built-In API Documentation → Generates comprehensive API documentation alongside SDKs, making it easy for developers to understand and use the API.
API Analytics and Observability → Provides insights into how your APIs and SDKs are being used by consumers.
Lightweight Tooling → Speakeasy is designed to be lightweight and easy to adopt, with a modern CLI and APIs for quick setup and management.

The first step is to install the Speakeasy CLI client. Fortunately, this can be easily done using Homebrew. Simply run the following command:

brew install speakeasy

This will set up the Speakeasy CLI on our system, allowing you to start working with it right away. Brew makes the installation process quick and hassle-free!

Once the installation is complete, the next step is to initialize Speakeasy by running the following command:

speakeasy quickstart

This command guides you through the setup process, making it easy to get started with Speakeasy. It’s designed to help you configure everything you need in just a few simple steps!

After running the speakeasy quickstart command, we’ll be prompted to select our workspace. Simply choose the appropriate workspace for our project, and once that’s done, you can return to the CLI to continue with the setup process. It’s a smooth and straightforward workflow designed to keep things efficient!

Selecting our workspace

Select OpenAPI Document Location

Naming our SDK

Choosing our language

Choosing the package name

Output directory for the generated SDK

Initilizing Git repo

Python SDK Generated

All done!

Back in the CLI, navigate to the dune-quotes-python folder using the following command:

cd dune-quotes-python

Once you’re in the folder, run the following command to install the necessary dependencies:

poetry install

This will ensure that all required packages are installed and our Python environment is properly set up, making it ready to work with the generated SDK:

from dune_quotes import DuneQuotes

client = DuneQuotes()

quotes = client.get_api_v1_quotes()

for quote in quotes:
    print(f'#{quote.character} ==> #{quote.quote}')

Speakeasy generated Python SDK

All good, but where’s the documentation? How are our users going to know how to use our API? Well, that’s easy. We just need to browse the generated folder and we will find the docs folder and inside the sdks folder and inside the duneQuotes folder and finally inside an README.md file:

Generated Documentation for the SDK

While the process was relatively straightforward, I found it to involve quite a few steps. Personally, it felt a bit more complex than I would have liked because there were so many steps for something that could had been just a single form instead of multiple screens, but that might just be my perspective. For someone looking for a quicker setup, the number of commands and configurations might feel a little overwhelming.

Kiota

A command-line tool for generating an API client to call any OpenAPI-described API you’re interested in.

Idiomatic SDK Generation → Supports multiple programming languages, including .NET, CLI, Go, Java, PHP, Python, and TypeScript.
Strong Typing and Validation → Generates SDKs with strongly-typed models to minimize runtime errors and improve code reliability.
Optimized for Microsoft Ecosystem → Initially designed to generate SDKs for the Microsoft Graph API, making it highly optimized for APIs with complex schemas.
Open Source → Fully open-source with an active development community.
Lightweight CLI Tool → Provides a simple and easy-to-use command-line interface (CLI) for generating SDKs.

Each programming language comes with its own specific set of instructions for setup and usage. Since there isn’t a predefined guide for Ruby, we’ll go with Python instead. Python’s instructions are well-documented and straightforward, making it a practical choice for this demonstration.

Let’s kick off by creating a brand-new folder to organize our project. We’ll name it kiota-duneQuotes to keep everything neat and aligned with the theme. To do this, simply run the command mkdir kiota-duneQuotes. This will generate an empty folder in the current directory, ready to house all the necessary files for our task.

Next, we need to transfer the OpenAPI specification, DuneQuotesSpec.yaml, into our newly created folder. This step ensures that all our resources are in the right place and easily accessible for the next stages of the project. To achieve this, use the command:

cp DuneQuotesSpec.yaml kiota-duneQuotes

Which will copy the spec into the kiota-duneQuotes folder.

Now, we have the groundwork set up and the OpenAPI specification safely stored in its designated directory, ready for further exploration and development.

We need to run the following commands to get the required dependencies:

pip install microsoft-kiota-abstractions
pip install microsoft-kiota-http
pip install microsoft-kiota-serialization-json
pip install microsoft-kiota-serialization-text
pip install microsoft-kiota-serialization-form
pip install microsoft-kiota-serialization-multipart

Before we dive any deeper into the process, there’s one crucial step we need to address: installing Kiota itself. While there are several ways to go about this, for the sake of simplicity and efficiency, we’re going to choose the method of using the Kiota binaries. This approach allows us to quickly set up Kiota without getting bogged down in dependencies or complex configurations.

To get started, we’ll download the Kiota binaries, ensuring that we have the right version for our operating system. Once the binaries are in place, we’ll be able to run Kiota commands seamlessly and proceed with generating our SDK without any interruptions.

Now that we’ve set everything up, we’re all set to generate the SDK files. This is the exciting part where the tools come together and start creating the necessary code for our project.

To generate the SDK files, we’ll use the kiota generate command, which will take the OpenAPI spec we’ve stored in the kiota-duneQuotes folder and generate a Python SDK for us. The command we’ll run is as follows:

kiota generate -l python -c PostsClient -n client -d DuneQuotesSpec.yaml -o ./client

Once the SDK is successfully generated, we can move on to the next important step: creating our test file. This test file will allow us to validate the functionality of the generated SDK, ensuring everything is working as expected and that we can interact with the API seamlessly.

We’ll need to create a new file where we can write our tests, using the SDK methods and functionality we’ve just generated. This will allow us to simulate interactions with the API, test various endpoints, and check for expected behaviors in a controlled environment.

By setting up a test file, we can catch any potential issues early and ensure that our SDK integrates smoothly with the rest of the application. Let’s proceed with creating the test file and diving into the testing process.

import asyncio
from kiota_abstractions.authentication.anonymous_authentication_provider import$
    AnonymousAuthenticationProvider)
from kiota_http.httpx_request_adapter import HttpxRequestAdapter
from client.posts_client import PostsClient

async def main():
    auth_provider = AnonymousAuthenticationProvider()
    request_adapter = HttpxRequestAdapter(auth_provider)
    client = PostsClient(request_adapter)

    quotes = await client.api.v1.quotes.get()

    for quote in quotes:
        print(f'#{quote.character} ==> #{quote.quote}')

asyncio.run(main())

Kiota generated Python SDK

While generating the SDK was a relatively straightforward process, integrating it into our sample script proved to be a bit more challenging. It took me some time to figure out the correct structure and how to properly invoke the SDK in our code. The complexity arose because the generated files weren’t immediately intuitive, and the documentation to guide us through this process wasn’t readily available.

I also ran into another roadblock: I haven’t been able to find any clear documentation on how to generate or access the documentation for the SDK itself. This lack of generated docs makes it a bit harder to understand the methods and properties available within the SDK, leaving us to rely more heavily on the generated code and trial-and-error to figure things out.

Despite these hurdles, I’ve been working through the process, experimenting with the generated files to uncover the right structure and method calls. It’s a bit more manual than I anticipated, but with persistence, I’m confident we can get it all running smoothly. If I do find a way to generate documentation or discover any helpful resources, I’ll be sure to share them to streamline the process moving forward.

AutoRest

Generate code from your OpenAPI definition using AutoRest

Multi-Language SDK Generation → Support for Python, C#, Java, TypeScript, Go, and PowerShell. Swift is coming.
API Documentation Generation → Generates API documentation alongside SDKs in various formats (Markdown, HTML, etc.).
Built-in Azure Support → Provides out-of-the-box integration with Azure SDKs and can generate Azure-specific client libraries.
Strong Typing and Validation → Generates strongly-typed models and client code, reducing runtime errors and improving code reliability.
Integration with CI/CD → Easily integrates with CI/CD workflows to ensure that SDKs and client libraries are kept up to date with API changes.

Let’s kick things off by installing AutoRest, a powerful SDK generation tool. Thankfully, the installation process is straightforward and can be done directly from the terminal. Simply run the following command:

npm install -g autorest

This command installs AutoRest globally on our system, making it accessible from anywhere in our terminal. Once installed, you’ll have all the tools you need to start generating SDKs efficiently. Let’s complete this setup so we can move on to exploring AutoRest’s capabilities!

Now, let’s generate a Python client using AutoRest. This process will take our API specification and create a fully functional SDK for interacting with it. To do this, run the following command in our terminal:

autorest --input-file=DuneQuotesSpec.yaml --python --output-folder=RestQuotes

Once you run this command, AutoRest will work its magic and generate a Python client within the RestQuotes folder.

Running AutoRest and getting some erros

Except, things didn’t go as smoothly as expected — AutoRest threw some rather cryptic errors during the generation process. At first glance, it wasn’t immediately clear what was causing the issue.

After some digging and troubleshooting, I discovered the root of the problem: each operation in the OpenAPI specification needs to have its own operationId tag. Without this, AutoRest struggles to correctly map and generate the SDK methods. This was unexpected, especially since other SDK generators I’ve used didn’t require this level of specificity.

While it caught me off guard, it’s not a showstopper. Adding unique operationId tags to the spec is a manageable fix, and once addressed, AutoRest should function as intended. It’s a small extra step, but one worth noting for anyone planning to use AutoRest with their OpenAPI specs.

Running AutoRest

With the operationId issue resolved, everything is back on track! The SDK has been successfully generated, and the output is neatly organized in the specified folder. We’re now ready to dive in, explore the generated files, and start integrating the SDK into our project. It’s great to see things running smoothly again!

Next, we’re ready to test our newly generated SDK client by creating a simple script. However, here’s where another hiccup surfaced. While preparing the script, I realized that the SDK depends on additional Python packages — but this wasn’t mentioned anywhere in the documentation!

To get the SDK client working properly, you’ll need to install the following dependencies:

pip install isodate
pip install azure-core

Now, it’s time to test our generated SDK with a simple test script. However, before we can run the script, there’s one more dependency we need to address. Since the SDK is built with Microsoft’s ecosystem in mind, you’ll need to install the azure-identity package to handle authentication.

You can do this easily by running the following command:

pip install azure-identity

This package provides essential authentication methods, such as support for Azure Active Directory credentials, ensuring our SDK can securely connect to the API.

While it’s another dependency to manage, it’s a necessary step to make the SDK functional. Once installed, we’ll be ready to dive into testing our script and seeing the SDK in action!

from RestQuotes import DuneQuotesAPI
from azure.identity import DefaultAzureCredential

client = DuneQuotesAPI(credential=DefaultAzureCredential())
quotes = client.get_quotes()

for quote in quotes:
    print(f'#{quote['character']} ==> #{quote['quote']}')

When it comes to documentation, I ran into a bit of a roadblock. Despite thoroughly exploring the available resources, I couldn’t find any clear instructions or guidance on how to generate documentation for the SDK.

This lack of information can be frustrating, especially for developers who rely on good documentation to understand and utilize an SDK effectively. It’s something that stands out compared to other SDK generator tools, many of which either generate documentation automatically or provide a straightforward way to do so.

If this feature exists, it’s not well-documented, which makes it harder to leverage the full potential of the generated SDK. Hopefully, future updates to the tool or its documentation will address this gap.

Conclusion

After thoroughly testing various SDK generation tools, here are my key takeaways for each of them:

Fern
Hands down, one of the best experiences I had. The entire process — from SDK generation to testing and documentation — was seamless. Fern was quick, intuitive, and required no extra steps for documentation generation. While some might criticize the lack of a UI, I appreciate Fern’s simplicity through a CLI installed via NPM — it appeals to my inner developer who wants to get straight to the point.

APIMatic
The SDK creation process was smooth and straightforward, just a great experience. Generating both the SDKs and documentation in a single step made for an excellent user experience. I thoroughly enjoyed the process.

OpenAPI Generator
The SDK creation process was simple and intuitive. However, calling it from a test script wasn’t as smooth as I had hoped, requiring a bit of extra effort to get things working because the source code was a bit too complex for my taste. On the bright side, its documentation generation was solid and sufficient for most use cases as it’s an HTML page with all the information about the generated SDK, although without any formatting or design.

Stainless
The SDK generation process was smooth, and having the generated SDK pushed to GitHub, complete with usage examples, was a nice touch. It’s a private repo on their organization which can be transferred to a production repo of our own. However, I couldn’t find any documentation generated for the SDK, which was a bit disappointing.

Speakeasy
While I didn’t enjoy navigating through multiple screens during the setup process, the overall experience was straightforward. It took me some time to locate the generated documentation, but it was there in the end.

Kiota
Kiota required installing several additional Python packages, which felt unnecessarily complicated. Moreover, the structure of the test script wasn’t user-friendly for me, and the lack of documentation for the generated SDK was a significant downside.

AutoRest
The issue with missing operationId tags in the OpenAPI spec caused some initial frustration and wasted time. However, once resolved, the process was smooth. Testing the generated SDK required an extra library installation, but this wasn’t a major obstacle. Unfortunately, like Kiota, I couldn’t find a way to generate documentation for the SDK.

Nylas and AI: Email and Calendaring for the Future

Alvaro (Blag) Tejada Galindo — Mon, 28 Aug 2023 10:25:24 +0000

Yes, we're hosting a Hackathon and you can join today.

What do I need to do?

Just create an application using any of our SDKs (Ruby, NodeJS, Java, Python) or calling our APIs directly and any Artificial Intelligence tool of your choice (ChatGPT, Hugging Face, Midjourney).

Are there any prizes?

Of course, here's the list for the first prize:

$5,000 USD
Virtual meeting with Nylas leadership
Blog post featuring the winning submissions

And here for the 5 runner ups:

$1,000 USD
Virtual meeting with Nylas leadership
Blog post featuring the winning submissions

I just signed up, now what?!

When you sign up, you will receive an started kit email with clear instructions, but, if you don't read it or your forget about it, it's critical that you create a free Nylas account (And mention that you are completing our Hackathon!), that will allow you to connect up to 10 email account.

Can I get some inspiration?

Sure you can, just watch some of our Coding with Nylas livestream episodes

How to Send an email using DearPyGUI, ChatGPT and your voice | Coding with Nylas | Episode 68

How to use AI to generate email responses

Localize your emails with ChatGPT and Python | Coding with Nylas | Episode 59

Python, Sentiment Analysis, Streamlit, and ChatGPT | Coding with Nylas | Episode 74

Nylas + AI Events: WeAreDevelopers Recap & Upcoming Events

Last words

Just follow the foxes advise 😉

A Small Introduction to Functional Programming

Alvaro (Blag) Tejada Galindo — Tue, 03 Jan 2023 20:48:02 +0000

Functional Programming is an old paradigm that’s gained popularity in recent years due to its code conciseness, modularity, and lack of side effects.

Based on Lambda Calculus, developed by Alonzo Church in the 1930s, functional programming has been implemented in mainstream programming languages like JavaScript, Python and Java. Programming languages like Erlang, Haskell or Scala are better suited for functional programming as they are designed to be functional first.

Many developers consider Lisp the first functional programming language. For newer incarnations, we can try Common Lisp or Racket.

What makes functional programming so unique?

Pure functions → The same input always produces the same output, and there are no side effects (no printing into the screen, mutating your input or changing the filesystem).

Function are First Class citizens → Function are treated as data. We can use them as variables, as input for other functions or as return values. Functions are everywhere.

Shorter code → Programs written in functional programming languages tend to be shorter than its counterparts like object oriented or imperative programming.

No loops → There’s no while, for, do while or anything of the sort as recursion is all you need.

What do we need?

In this post, we’re going to explore some key fundamentals of functional programming using examples in two different functional languages and you’re invited to install them both, or just install what you want or need.

Haskell (1990 / Purely Functional) → If we’re on a Mac, the best way is to use homebrew and type on the terminal window:

$ brew install ghc cabal-install

Where ghc is the Glasgow Haskell Compiler and Cabal is Haskell’s package manager.

For other systems, you can refer to the download page.

Erlang (1986 / Concurrent and Functional) → Again, if on a Mac, type:

$ brew install erlang

Or you can refer to the download page.

Immutable variables

In functional programming, once a variable is assigned it can never change. You can think of that as using constants all the time.

Erlang

In Erlang variables begin with an Uppercase letter and once assigned they cannot be changed.

Haskell

In Haskell variables don’t follow any structure. Create a file called variables.hs and type the following:

a = 1
a = 5

Then open a terminal window on the same folder as your file and run ghci, then :l variables to load your program.

Pattern Matching

In short terms, pattern matching allows us to define how the same function will react to different parameters. This means that calling the function myFunction with no parameters will be different from calling myFunction with two parameters and different from calling it with five parameters and even different when calling it with different parameter values.

Let’s create an Erlang example called greetings.erl:

-module(greetings).
-export([greet/2]).
greet(male, Name) ->
    io:format("Good morning Mr. ~s~n", [Name]);
greet(female, Name) ->
    io:format("Good morning Mrs. ~s~n", [Name]);
greet(_, Name) ->
    io:format("Good morning ???. ~s~n", [Name]).

When we run it, we can see that we can call the same function but using different parameters and it will always run as expected.

Anonymous functions

Anonymous functions are functions that do not have a name. We can call them just once. We use them to define functions that are not meant to be called multiple times.

Let’s see an example calling a function to manipulate a list. We’re going to write a file called lambdas.hs:

func :: Integer -> Integer
func num = num * 2 + 10
show_nums :: [Integer] -> [Integer]
show_nums lst = map func lst

We need to call the Haskell compiler to read our file:

$ ghci 
$ :l lambdas.hs

And then call it like this:

$ show_nums [1,2,3,4,5]

While this is simple, we don’t really need the func function, so let’s change the source code like this:

show_lambdas :: [Integer] -> [Integer]
show_lambdas lst = map (\xs -> xs * 2 + 10) lst

And it will yield the same exact result, but with half the code lines:

Closures

A closure is a function inside a function that gets access to its parent function variables. Sounds strange, huh? Let’s see an Erlang example:

We’re going to write this example on a file called closures.erl:

-module(closures).
-export([start/1]).
start(Name) ->
  GreetPerson = fun() ->
    io:format("Hello and welcome ~s.~n", [Name]),
    fun() -> io:format("Goodbye ~s. Nice to meet you.~n", [Name]) end
  end,
  Greet = GreetPerson(),
  Greet().

To run this we need to compile the file first by typing on the terminal:

$ erlc closures.erl

A closures.beam file gets generated, which is a file that will be interpreted by the Erlang VM.

After compilation, we need to open the Erlang VM and run it.

$ erl

$ closures:start(“Blag”).

This will run and execute our code:

Here we can see that by calling Greet = GreetPerson(), we’re assigning the function GreetPerson() to the variable Greet. When we call Greet(), we’re greeting the person, but we’re also running an anonymous function that will say goodbye to the user. Notice that we’re not calling this anonymous function directly.

List Comprehensions

List comprehensions are a way to build or modify lists, and it is worth mentioning that lists are the most used type in functional programming.

Using list comprehensions, we could rewrite the lambdas example. This time, let’s use Erlang and create a file called list_comprehensions.erl with the following code:

-module(list_comprehensions).
-export([start/1]).
start(List) -> 
  [X * 2 + 10 || X <- List].

When we run this, it will return the same result:

Recursion

When using Recursion, a function calls itself multiple times, and this is not a foreign topic on non-functional programming languages, but the way it’s implemented and used is for sure different.

To make more sense of this, let’s see how a factorial source will look like in Ruby:

def fact(n)
  if n == 0
    1
  else
    n * fact(n-1)
  end
end
puts fact(5)

We can write the same on Haskell, like this:

factorial :: Int -> Int
factorial 0 = 1
factorial n = n * factorial (n - 1)

The code is shorter and simpler:

And that’s it for a small introduction to functional programming.

Like what you read but looking for some Nylas content, make sure to check our great selection of blog posts.

Don’t miss the action, watch our LiveStream Coding with Nylas:

Send and Read Emails Using Node-Red and the Nylas APIs

Alvaro (Blag) Tejada Galindo — Fri, 16 Dec 2022 15:54:17 +0000

If you’re a regular reader of our DevRel blogs, you might know that we had published several blogs on how to send and read emails using Nylas SDKs for languages like Python, Ruby, NodeJS and Java. We also have talked about using PHP, C#, and Rust.

Today, we’re going to learn how to send and read emails using Node-Red, a low-code programming environment based on NodeJS, that is mostly used for IoT scenarios.

Installing Node-Red

We can use npm to install Node-Red by typing the following in the terminal window:

$ sudo npm install -g --unsafe-perm node-red

If you’re on Windows, don’t use sudo.

Once installed, we can simply call it from the terminal like this:

$ node-red

And it will run the editor on the following address:

http://127.0.0.1:1880/

The Node-Red environment

Being a visual environment, we can simply drag and drop elements into the canvas, and connect them via wires:

Installing Nodes

In Node-Red, we can install additional Nodes that will help us in making our work easier.

We’re going to install sysmessage, a node that will allow us to create notifications in a simple and easy way.

First, we need to press the menu button on the right hand side:

Then select Manage Palette:

Then, on the Install tab, type sysm (to bring up autocompletion) on the search box and click on Install:

Once installed, a new node will appear on the left section on our canvas:

Sending an email

Now, we’re ready to send our email.

First, we’re going to select an Inject node and drag it into the canvas:

With a double click, we can access its properties. We want to delete the msg.topic message:

We need to choose timestamp and change it for JSON:

Then, select the three points to expand the editor:

And paste the following JSON code:

{
   "subject": "Hello from Node-Red",
   "to": [
       {
           "email": "devrel@nylas.com",
           "name": "Nylas' DevRel Team"
       }
   ],
   "body": "This email was sent using Node-Red and the Nylas APIs."
}

Now, we’re going to drag an http request node:

Here, we need to change the Method to POST and pass the Nylas Send Endpoint which is https://api.nylas.com/send. Then, we need to tick on Use authentication and select bearer authentication and pass our access token. Lastly, we need to add a couple of headers, Accept and Content-Type.

Once that’s done, we need to drag and add the sysmessage node and configure it like this; Choose the type of alert, OSX Alert in this case, and add an appropriate title. Leave the rest as it is.

Connect all the nodes with wires so it will look like this:

Or, you can simply copy and paste the following JSON code.

Paste the JSON code and press Import.

We should have all nodes ready to be pasted. Once we finish, we can press the Deploy button, which is located next to the menu button.

Once deployed, we just need to press the Inject note in order to send the email and get the notification message.

Also, we will get the JSON response back from calling the Nylas API.

With minimal effort and no code, we sent an email using Node-Red and the Nylas APIs.

Reading Emails

Sending email was simple and almost straightforward, but reading email gets a little bit complicated. No worries, it will be fun.

First, we’re going to create an http in node.

And configure it like this:

The method is GET, the URL will include /:limit which is going to how many emails we want to fetch and the Name is actually optional.

We can also add an extra http in node and get the URL but without the /:limit as this will help us to define a default page.

We’re going to add a Change node. This will allow us to read the /:limit parameter from before.

The name is optional, but the SET and to the value are very important. We’re getting the parameter value and assigning it to the payload.

This parameter is going to be a String, but we need an Integer. So, we need to add a Function node and type the following:

if (msg.payload == null){
   msg.payload = "5";
}
msg.payload = Number(msg.payload);
return msg;

This code will simply check if we are passing or not the :limit parameter and if we’re not, pass 5 as the limit, then it will convert the String parameter to an Integer parameter.

The next step will be to add an http request node. It will be the same as Sending an email but the URL would be

https://api.nylas.com/messages?in=inbox&limit={{{payload}}}

and the return will be a parsed JSON object instead of a UTF-8 String.

On the URL,

**https://api.nylas.com/messages?in=inbox&limit={{{payload}}}**

the in=inbox part means that we’re reading mail coming from the inbox only, and the

**limit={{{payload}}}**

means that the amount of emails that we want to fetch would be the same as the number we used as parameter.

We’re going to get back an array of emails, and we need to access them one by one, so our best choice is to use the split node:

This node will grab each item in the array of emails. What we want to do is to change the format of the date field, as it is currently displayed as Epoch (number of seconds since January 01, 1970) and we want something more human readable. The best thing is that we don’t need to modify any property of this node; we can use it just as it comes.

This is the code for the function:

msg.payload.date = new Date(msg.payload.date * 1000).toLocaleString();
return msg;

Once we’re done fixing the dates, it’s time to make the elements an array again, and for that we need to use the join node, which in the same manner as split, can be used without any further modifications.

Once the array is ready and back in place, we need to display the information from the emails, and for that we can use the template node. This node uses the mustache system, which is a logicless template engine for creating dynamic content. In other words, it generates HTML code by using tags that are replaced by code.

This is the code that we will need to use:

<html>
   <head>
       <script src="https://cdn.tailwindcss.com"></script>
   </head>
<body>
<h1 class="font-black" style="text-align:center">Inbox</h2>
<table class="table-auto">
   <tr>
       <th>Subject</th>
       <th>From (Name)</th>
       <th>From (Email)</th>
       <th>Date</th>
       <th>Snippet</th>
   </tr>
   {{#payload}}
   <tr>
   <td>
   {{subject}}
   </td>
   <td>
   {{from.0.name}}
   </td>
   <td>
   {{from.0.email}}
   </td>   
   <td>
   {{date}}
   </td>   
   <td>
   {{snippet}}
   </td>
   </tr>
   {{/payload}}
</table> 
</body>
</html>

This will simply create a table, loop each record of the array and print out the subject, name and email of sender, date and the snippet (email preview).

The last piece is the http response node which will allow us to see the template on the web browser.

We don’t need to change anything on this node.

Once we click on Deploy, we can start testing.

Our canvas should look like this one:

And of course, we can import the following JSON code.

On our browser of choice, we need to navigate to:

http://localhost:1880/GetEmails

And we will get the first five emails in our inbox:

And we can also pass parameters, so calling it this way:

http://localhost:1880/GetEmails/1

This will fetch just one email.

We can choose any number from one to one hundred (as that’s currently the fetch limit).

And that’s it. Hope you like this one. Sending and reading emails using Node-Red and the Nylas APIs is both fast and easy.

If you want to learn more about email management with Nylas, visit our documentation page Email API Overview.

Watch the Coding with Nylas episode 18 - Send and Read emails using Node-Red.

How to Send an Email in Any Language Using the Nylas APIs

Alvaro (Blag) Tejada Galindo — Wed, 14 Dec 2022 08:49:31 +0000

If you’ve been reading our posts, then you know how to send emails using Ruby, Python and Node.

But you may be wondering, can I use something else? Can I use PHP, Rust or C#?

Well, the simple answer is yes, we absolutely can. Nylas provides APIs, not only SDKs, so we can use any available programming language that supports Rest API calls.

We’re going to display some examples and take them more as a proof-of-concept than real applications. There are several ways to consume APIs and the intention of this blog post is just to show one way of doing that.

Sending an Email using PHP and Nylas Apis

First, we need to have PHP installed as well as Composer (A dependency manager for PHP). Using Composer, we need to install dotenv which will allow us to read .env files.

$ composer require vlucas/phpdotenv

Inside the .env file we need to pass our access token that we can easily gather from the Nylas Dashboard.

ACCESS_TOKEN=access_token

Then, we can create our script and call it SendEmail.php:

<!DOCTYPE HTML>
<html>
<head>
</head>
<body>
<?php
# Import your dependencies
require_once('vendor/autoload.php');

# Load env variables
$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
$dotenv->load();

# Initialize variables
$result = "";
# If we're working with a POST method
if ($_SERVER["REQUEST_METHOD"] == "POST") {
# Required fields for Email API
$fields = array(
            'subject' => $_POST["subject"],
            'body' => $_POST["body"],
            'to' => array([
                 'name' => $_POST["to_name"],
                 'email' => $_POST["to_email"]
            ]),
        );  

# Headers with Authorization and type
$headr = array();
$headr[] = 'Accept: application/json';
$headr[] = 'Content-type: application/json';
$headr[] = 'Authorization: Bearer ' . $_ENV['ACCESS_TOKEN'];

# Call the Send Email API
$ch = curl_init( "https://api.nylas.com/send" );
# Encode the data as JSON
$payload = json_encode( $fields );
# Submit the Email information
curl_setopt( $ch, CURLOPT_POSTFIELDS, $payload );
# Submit the Headers
curl_setopt( $ch, CURLOPT_HTTPHEADER, $headr);
# We're doing a POST
curl_setopt($ch, CURLOPT_POST, true);
# Return response instead of printing.
curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
# Send request.
$result = curl_exec($ch);
# Close request
curl_close($ch);
}
?>

<!-- Create the Form -->
    <h2>Send an Email using PHP and the Nylas APIs</h2>
    <form method="post" action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]);?>">
    To Name: <input type="text" name="to_name">
    <br><br>
    To Email: <input type="text" name="to_email">
    <br><br>    
    Subject: <input type="text" name="subject">
    <br><br>
    Body: <textarea name="body" rows="5" cols="40"></textarea>
    <br><br>
    <input type="submit" name="submit" value="Submit"> 
    </form>

<?php
    echo "$result";
?>  

</body>
</html>

Instead of saving this on our Apache folder, we will keep it where our PHP scripts reside and simply type this on the terminal:

$ php -S 127.0.0.1:8000

This will call PHP’s internal web server. Going to our favourite browser we can pass the following address:

http://localhost:8000/SendEmail.php

And a form will be displayed:

We need to fill in the recipient’s name, the recipient’s email, the subject and the body of the email. Once we press Submit, we will get a raw response indicating that everything was fine.

The email was successfully delivered.

You can check the Github repo here.

You can watch the LiveStream video here.

Sending an Email using Rust and Nylas Apis

Next, let’s use Rust. We’re going to use Cargo (Rust’s Dependency Manager) which is bundled inside Rust.

$ cargo new send_email

This will create two different files. The first one called Cargo.toml:

[package]
name = "send_email"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
reqwest = { version = "0.11", features = ["json"] } # reqwest with JSON parsing support
futures = "0.3" # for our async / await blocks
tokio = { version = "1.12.0", features = ["full"] } # for our async runtime
serde_json = "1.0" #to handle json
dotenv = "0.15.0" # for reading .env file

[profile.release]
opt-level = 'z'     # Optimize for size.
lto = true          # Enable Link Time Optimization
codegen-units = 1   # Reduce the number of codegen units to increase optimizations.
panic = 'abort'     # Abort on panic
strip = true        # Strip symbols from binary*

The second one called main.rs:

// Import your dependencies
use reqwest; //HTTP Client
use std::io;
use serde_json::json; //Json handler
use std::env;

// tokio let's us use "async" on our main function
#[tokio::main]
async fn main() {

// Read the .env file
dotenv::dotenv().expect("Failed to read .env file");

// Add the ACCESS_TOKEN to the Authorization string
let mut _access_token = String::new();
_access_token = "Bearer ".to_owned() +  &env::var("ACCESS_TOKEN").expect("Not found");

// Request the parameters
println!("Enter a subject: ");
let mut _subject = String::new();
io::stdin().read_line(&mut _subject)
             .expect("failed to read");

println!("Enter a name: ");
let mut _name = String::new();
io::stdin().read_line(&mut _name)
              .expect("failed to read");

println!("Enter an email: ");   
let mut _email = String::new();
io::stdin().read_line(&mut _email)
              .expect("failed to read");

println!("Enter the body: ");              
let mut _body = String::new();
io::stdin().read_line(&mut _body)
              .expect("failed to read");

let trim_subject = _subject.trim();
let trim_name = _name.trim();
let trim_email = _email.trim();
let trim_body = _body.trim();

// Create the JSON structure
let _fields = json!({
    "subject": &trim_subject,
    "to": [
    {
      "email": &trim_email,
      "name": &trim_name
    }
  ],
  "body": &trim_body,
});

    let client = reqwest::Client::new(); //Create HTTP client
    let response = client //Call API passing parameters
        .post("https://api.nylas.com/send")
        .header("Authorization", _access_token.to_string())
        .header("Content-type", "application/json")
        .header("Accept", "application/json")
        .json(&_fields)
        .send()
        .await
        .unwrap() // Give the back the result of panic if it fails
        .text() // Convert it to plain text
        .await;

    println!("{:?}", response);
}

We must not forget to create the .env file:

ACCESS_TOKEN=access_token

Once we have everything, we need to release our application by typing on the terminal:

$ cargo build --release

Once it’s has been built:

$ ./send_email

Just like in the PHP example, the email was successfully delivered.

You can check the Github repo here.

You can watch the LiveStream video here.

Sending an Email using C# and Nylas Apis

Finally, we’re going to use C#. And for this, we’re going to need to install Visual Studio Code.

To start, let’s head to our Terminal and type the following:

$ mkdir send_email && cd send_email

Once we created a new folder and entered that folder, we need to type:

$ dotnet new console

That will create the following files: Program.cs and send_email.csproj

Now, we need to open Visual Studio Code and press Open:

Then, choose your folder send_email and open it:

This will open up the editor and your files.

On send_email.csproj we need to include the following code:

<Project Sdk="Microsoft.NET.Sdk">

 <PropertyGroup>
   <OutputType>Exe</OutputType>
   <TargetFramework>net6.0</TargetFramework>
   <ImplicitUsings>enable</ImplicitUsings>
   <Nullable>enable</Nullable>
 </PropertyGroup>

 <ItemGroup>
   <PackageReference Include="DotNetEnv" Version="2.3.0" />
   <PackageReference Include="RestSharp" Version="106.15" />
 </ItemGroup>

</Project>

The RestSharp package will help us to consume REST APIs and the DotNetEnv will help us read .env files

This is the code for the Program.cs file:

// Import packages
using RestSharp;
using System;

// Load .env file
DotNetEnv.Env.Load();
DotNetEnv.Env.TraversePath().Load();

// Ask via the user via console
Console.WriteLine("Enter subject:");
string _subject = System.Console.ReadLine();
Console.WriteLine("Enter name:");
string _name = System.Console.ReadLine();
Console.WriteLine("Enter email:");
string _email = System.Console.ReadLine();
Console.WriteLine("Enter body:");
string _body = System.Console.ReadLine();
// Create a new Rest Client and call the Nylas API endpoint
var client = new RestSharp.RestClient("https://api.nylas.com/send");
// Wait until the connection is done
client.Timeout = -1;
// We want a POST method
var request = new RestSharp.RestRequest(Method.POST);
// Adding header and authorization
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Authorization", "Bearer " + System.Environment.GetEnvironmentVariable("ACCESS_TOKEN"));

// Formatting the body of our request
var body = @"{"
   + "\n"
   + $@"    ""body"" : ""{_body}"","
   + "\n"
   + $@"    ""subject"": ""{_subject}"","
   + "\n"
   + $@"    ""to"": ["
   + "\n"
   + @"        {"
   + "\n"
   + $@"            ""name"": ""{_name}"","
   + "\n"
   + $@"            ""email"": ""{_email}"""
   + "\n"
   + @"        }"
   + "\n"
   + @"    ]"
   + "\n"
   + @"}";

// Adding the body as a parameter
request.AddParameter("application/json", body, ParameterType.RequestBody);
// We send the request
IRestResponse response = client.Execute(request);
// Print the response
Console.WriteLine(response.Content);
// Wait for user input before closing the terminal
Console.Read();

We must not forget to create the .env file:

ACCESS_TOKEN = access_token

Once we have everything, we need to release our application by running it without debugging:

This will generate an executable file that we can execute by going to:

$ cd bin/Debug/net6.0

And running the application:

$ ./send_email

Just like in the PHP and Rust examples, the email was successfully delivered:

You can check the Github repo here.

If you want to learn more about our Email API, please go to our Email API documentation.

Grouping Email Threads with Ruby and Nylas

Alvaro (Blag) Tejada Galindo — Fri, 09 Dec 2022 11:56:52 +0000

Looking for emails is straightforward, however, trying to get them all in a single place with less noise can be a difficult task. Thanks to the Nylas Ruby API, we can make email threading possible.

If you want to learn more about Email Threads, read the blog post Stay Threaded: How to Manage and Control Email Threads

Is your system ready to group email threads?

If you already have the Nylas Ruby SDK installed and your Ruby environment is configured, then continue along with the blog.

Otherwise, I would recommend that you read the post How to Send Emails with the Nylas Ruby SDK where the basic setup is explained.

What are we going to talk about?

What does our application look like?
Installing the Sinatra package
Running our Email Threading application

What does our application look like?

Before we jump into the code, let’s see how our application actually works. We will have a single input field accepting the email address to get all the related email threads and messages included in those threads:

We’re going to list all email threads related to the address we used, as long as they have at least two messages:

The email threads are presented in an accordion, and when we open one, we will get the emails in a sequence, with the contact image and with the noise removed. So no emails, phone numbers or reply texts.

As we can see, both simple and nice.

Installing the Sinatra package

To create a Ruby web application, our best option is to use Sinatra, one of the most popular Micro Frameworks in the Ruby world. We might need to install some additional gems:

$ gem install sinatra $ gem install puma $ gem install nokogiri

Once installed, we’re ready to go:

First, we’re going to create a folder called EmailThreading, and inside we’re going to create two folders, one called views and other called public.

Let’s create a file called EmailThreading.rb in the EmailThreading folder, and add the following code:

# Import your dependencies
require 'dotenv/load'
require 'nylas'
require 'sinatra'
require 'nokogiri'
require 'date'

# Initialize your Nylas API client
nylas = Nylas::API.new(
    app_id: ENV["CLIENT_ID"],
    app_secret: ENV["CLIENT_SECRET"],
    access_token: ENV["ACCESS_TOKEN"]
)

# Use the Nokogiri gem to clean up the email response
def clean_content(raw_html)
    html = raw_html.encode('UTF-8', invalid: :replace, undef: :replace, 
                         replace: '', universal_newline: true).gsub(/\P{ASCII}/, 
                         '')
    parser = Nokogiri::HTML(html, nil, Encoding::UTF_8.to_s)
    parser.xpath('//script')&.remove
    parser.xpath('//style')&.remove
    parser.xpath('//text()').map(&:text).join('<br> ')
end

# Get the contact associated to the email address
def get_contact(nylas, email)
    contact =  nylas.contacts.where(email: email)
    if contact[0] != nil
        return contact[0]
    end
end

# Download the contact picture if it's not stored already
def download_contact_picture(nylas, id)
    if id != nil
        contact = nylas.contacts.find(id)
        picture = contact.picture
        file_name = id + ".png"
        File.open("public/" + file_name,"wb") do |f|
            f.write File.open(picture, 'rb') {|file| file.read }
        end
    end
end

# When calling the application for the first time
get '/' do
    _threads = []
    # Call the page
    erb :main, :layout => :layout, :locals => {:threads => _threads}
end

# When asking for the email threading
post '/search' do
    # Get parameter from form
    search = params[:search]
    # Search all threads related to the email address   
    threads = nylas.threads.where(from: search,in: 'inbox') 

    _threads = []

    # Loop through all the threads  
    threads.each{ |thread|
        _thread = []
        _messages = []
        _pictures = []
        _names = []
        # Look for threads with more than 1 message     
        if thread.message_ids.length() > 1
            # Get the subject of the first email        
            _thread.push(thread.subject)
            # Loop through all messages contained in the thread
            thread.message_ids.each{ |message|
                # Get information from the message          
                message = nylas.messages.find(message)
                # Try to get the contact information                
                contact = get_contact(nylas, message.from[0].email)
                if contact != nil and contact != ""
                    # If the contact is available, downloads its profile picture
                    download_contact_picture(nylas, contact.id)
                end
                # Remove extra information from the message, like appended 
                #  message, email and phone number
                _messages.push(clean_content(message.body).
                    gsub(/(\bOn.*\b)(?!.*\1)/,"").
                    gsub(/[a-z0-9._-]+@[a-z0-9._-]+\.[a-z]{2,3}\b/i,"").
                    gsub(/(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}/,"").
                    gsub(/twitter:.+/i,""))
                    # Convert date to something readable
                    datetime = Time.at(message.date).to_datetime
                    date = datetime.to_s.scan(/\d{4}-\d{2}-\d{2}/)
                    time = datetime.to_s.scan(/\d{2}:\d{2}:\d{2}/)
                    if contact == nil or contact == ""
                        _pictures.push("NotFound.png")
                        _names.push("Not Found" + " on " + date[0] + " at " + 
                                    time[0])
                    else
                        # If there's a contact, pass picture information, 
                        # name and date and time of message
                        _pictures.push(contact.id + ".png")
                        _names.push(contact.given_name + " " + contact.surname + 
                                    " on " + date[0] + " at " + time[0])
                    end
            }
            _thread.push(_messages)
            _thread.push(_pictures)
            _thread.push(_names)
            _threads.push(_thread)
        end
    }

    # Call the page and display threads 
    erb :main, :layout => :layout, :locals => {:threads => _threads}
end

Inside the views folder, we need to create two different files, let’s start with layout.erb:

<!DOCTYPE html>
<html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<!-- Call the TailwindCSS and Flowbite libraries -->
<script src="https://cdn.tailwindcss.com"></script>
<link rel="stylesheet" href="https://unpkg.com/flowbite@1.5.3/dist/flowbite.min.css" />
<title>Nylas’ Email Threading</title>
<body>
<%= yield %>
<script src="https://unpkg.com/flowbite@1.5.3/dist/flowbite.js"></script>
</body>
</html>

We’re calling both the TailwindCSS and Flowbite libraries to handle CSS.

We need to create then the file main.erb:

<div class="grid bg-green-300 border-green-600 border-b 
           p-4 m-4 rounded place-items-center">
<p class="text-6xl text-center">Email Threading</p><br>
<!-- Create the form-->
<form method = "post" action="search">
<div class="flex bg-blue-300 border-blue-600 border-b p-4 m-4 rounded place-items-center">
<input type="text" name="search" value="" size="50"></input>&nbsp;&nbsp;
<button type="submit" class="block bg-blue-500 hover:bg-blue-700 
  text-white text-lg mx-auto py-2 px-4 rounded-full">Search</button>
</div>
</form>
<!-- Do we have any threads? -->
<% if threads != [] %>
<div id="accordion-collapse" data-accordion="collapse">
<!-- Counter to generate accordion elements -->
  <% counter = 1 %>
<!-- Loop through each thread -->  
  <% threads.each do |thread| %>
<!-- Define values for the accordion elements -->  
    <% heading = "accordion-collapse-heading-" + counter.to_s  %>
    <% body = "accordion-collapse-body-" + counter.to_s  %>
    <% _body = "#accordion-collapse-body-" + counter.to_s  %>
  <h2 id=<%= heading %> >
    <button type="button" class="flex items-center justify-between w-full p-5 font-medium 
                                 text-left text-gray-500 border border-b-0 border-gray-200 
                                 focus:ring-4 focus:ring-gray-200 dark:focus:ring-gray-800 
                                 dark:border-gray-700 dark:text-gray-400 hover:bg-gray-100 
                                 dark:hover:bg-gray-800" data-accordion-target=<%= _body %> 
                                 aria-expanded="false" aria-controls=<%= body %>>
<!-- Title of the thread -->
      <span><%= thread[0] %></span>
      <svg data-accordion-icon class="w-6 h-6 shrink-0" fill="currentColor" 
        viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill-rule="evenodd"    
        d="M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 
        4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z" clip-rule="evenodd"></path></svg>
    </button>
  </h2>     
  <div id=<%= body %> class="hidden" aria-labelledby=<%= heading %>>
  <div class="p-5 font-light border border-b-0 border-gray-200 dark:border-gray-700">
  <!-- Get size of thread array -->
  <% count = thread[1].length() %>
  <!-- Define amount of elements on the grid -->    
  <% count_str = "grid-rows-" + count.to_s %>
  <div class="grid <%= count_str %> grid-flow-col gap-4">
  <!-- Counter to access array elements --> 
    <% counter = 0 %>
    <!-- Loop through each email -->        
    <% thread[1].each do |message| %>
      <div class="col-span-2 ...">
      <!-- Display image and date/time of email -->             
    <img class="mx-auto" src="<%= thread[2][counter] %>"><b>
        <p class="text-center"><%= thread[3][counter] %></p></b><br>
        <!-- Display the email message -->
    <%= message %>
      </div>
    <% counter = counter + 1 %>
        <% end %>
    </div>
    </div> 
  </div>    
  <% end %>
</div>
<% end %>
</div>

If you wonder about the public folder, it will only hold the contact profile picture, so there’s nothing we need to do there.

And that’s it. We’re ready to roll.

Running our Email Threading application

In order to run our application, we just need to type the following on the terminal window:

$ ruby EmailThreading.rb

Our application will be running on port 4567 of localhost, so we just need to open our favourite browser and go to the following address:

http://localhost:4567

If you want to learn more about our Email APIs, please go to our documentation Email API Overview as well Threads and Messages.

Python, Sentiment Analysis, R and Shiny

Alvaro (Blag) Tejada Galindo — Tue, 21 Jun 2022 03:12:42 +0000

Knowing how your customers feel about your product is as important as creating a good product. Wouldn’t it be great if we could determine in a simple way how our customers feel by analyzing the feedback they provide via email messages? With Nylas Neural API’s Sentiment Analysis, we can do that. Sentiment Analysis is a way of computationally analyzing a writer’s work to determine how they feel about a selected topic. With basic sentiment analysis, you can check if the writer feels positive, negative, or neutral about something.

For this post, we’re going to create a simple feedback web page using Python. The sentiment information we gather will be analyzed and stored locally in a SQLite Database to be later picked up and displayed in a Shiny Dashboard using the R Programming Language. (Shiny is an R package that lets you easily display data with a variety of charts and graphs in your own dashboard.) We’re keeping everything local just for the sake of simplicity.

Is your system ready?

If you don’t have the Nylas Python SDK installed and your environment isn’t configured, I would recommend you to read the post How to Send Emails with the Nylas Python SDK where everything is clearly explained.

To complete this project you will need:

Nylas developer account and credentials
Nylas Python SDK installed
Gmail account (we will use Gmail to label and sort emails)
We will install R and Shiny later in this post, so you don’t need to worry about it now

What are we going to do?

Let’s pretend that we are the owners of a small company that produces vegan eggs called “VeggiEggs”. We want to build a Flask application that will collect feedback from our customers and send it to us via email, so that we can store the information and also reply back as a follow up. Then we want a Python script that will read and analyze every email using Sentiment Analysis and finally create an R Shiny Script that will display a dashboard with the information we gathered.

Working on the application

What we need to do first is set up a Label so that the emails are easy to find.

Creating a Label

On Gmail, we can do the following:

On the search bar, press the “Show Search Options” button.

Then, use the “veggieggs” and “feedback” words.

When we create the filter, we can assign the messages to an existing label or create a new one.

We don’t need to nest it, so just enter the label name.

Once we create it, we can apply some extra filters

Now, every email that we receive containing those words “VeggieEggs” and “Feedback” will go into our label and skip the inbox.

Installing the Flask package

As we want to create a Python web application, our best option is to use Flask, one of the most popular Micro Frameworks in the Python world.

To install it, we can type the following command on the terminal:

$ pip3 install flask

Once installed, we’re ready to go.

Creating the Flask application

As we’re going to develop this application locally and not deploy it anywhere else. We’re going to create a file called config.json which will hold our Nylas Tokens information. This comes with Flask, so why not use it?

{
  "NYLAS_OAUTH_CLIENT_ID": "<YOUR_CLIENT_ID>",
  "NYLAS_OAUTH_CLIENT_SECRET": "<YOUR_CLIENT_SECRET>",
  "SECRET_KEY": "<YOUR_SECRET_KEY>"
}

Now, we’re going to create a file called FeedbackForm.py which will handle getting the feedback and sending the email.

# Import your dependencies
from flask import Flask,render_template,json,request,flash,redirect,url_for
from nylas import APIClient

# Create the app and read the configuration file
app = Flask(__name__)
app.config.from_file("config.json", json.load)

# Initialize your Nylas API client
def load_nylas():
    nylas = APIClient(
        app.config["NYLAS_OAUTH_CLIENT_ID"],
    app.config["NYLAS_OAUTH_CLIENT_SECRET"],
    app.config["SECRET_KEY"]
    )
    return nylas

# This the landing page
@app.route("/", methods=['GET','POST'])
def index():
# If we are reading the page, show the feedback form
    if request.method == 'GET':
        return render_template('FeedbackForm.html')
# If we are submitting feedback, read the form
    else:
        name = request.form['name']
        email = request.form['email']
        rating = request.form['rating']
        comments = request.form['comments']

# Check for required fields
        if not name:
            flash('Name is required!')
            return redirect(url_for('index'))
        elif not email:
            flash('Email is required!')
            return redirect(url_for('index'))
        elif not comments:
            flash('Comments are required!')
            return redirect(url_for('index'))           
        else:
# If everything is Ok, send the email with the feedback information
            nylas = load_nylas()
            draft = nylas.drafts.create()
            draft.subject = "VeggiEggs Feedback - {} - {} - {}".format(name, email, rating)
            draft.body = comments
    draft.to = [{"name": "<YOUR_NAME>", "email": "<YOUR_EMAIL>"}]

    draft.send()            
    return render_template('ConfirmationForm.html', 
                   name = name, email = email, 
                   rating = rating, comments=comments),            
                                                  {"Refresh":"5;url=/"}

# Run our application       
if __name__ == "__main__":
    app.run()

For this to work properly, we need to create a file called FeedbackForm.html and we’re going to use TailwindCSS to provide a quick look and feel.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <script src="https://cdn.tailwindcss.com"></script>
    <title>Nylas</title>
</head>
<body>
    <div class="bg-green-300 border-green-600 border-b p-4 m-4 rounded">
    {% block content %}
    {% with messages = get_flashed_messages() %}
        {% if messages %}
            {% for message in messages %}
                {{ message }}
            {% endfor %}
        {% endif %}
    {% endwith %}
    <h1 class="font-black">We hope you enjoyed VeggiEggs. Please take some time to leave a review</h1>
    <br>
    <form method="post">
        <label for="name" class="font-bold">* Name</label>
        <input type="text" name="name"
               placeholder="Your name"
               value="{{ request.form['name'] }}"></input>
        <br><br>
        <label for="email" class="font-bold">* Email</label>
        <input type="email" name="email"
               placeholder="Your email"></input>
        <br><br>
        <label for="rating" class="font-bold">Choose a rating:</label>
        <select name="rating">
            <option value="1">Poor</option>
            <option value="2">Fair</option>
            <option value="3">Ok</option>
            <option value="4">Good</option>
            <option value="5" selected>Great</option>
        </select><br><br>
        <p class="font-bold">* Comments</p>
        <textarea name="comments"
               placeholder="Your comments"
               rows=5
               cols=50></textarea>        
        <br><br>
        <button type="submit" class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded-full">Submit</button>
    </form>
    <p class="font-bold">* Required</p>
    {% endblock %}
    </div>
</body>
</html>

And we’re going to need a confirmation page as well, so that people know that their responses were recorded correctly.

We're going to create a page called ConfirmationForm.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <script src="https://cdn.tailwindcss.com"></script>
    <title>Nylas</title>
</head>
<body>
    <div class="bg-green-300 border-green-600 border-b p-4 m-4 rounded">
    {% block content %}
    <h2 class="font-semibold">Thanks {{name}} - {{email}}</h2>
    <h2 class="font-semibold">Your rating was: {{rating}}</h2>
    <h2 class="font-semibold">Your comments were:<br><br> {{comments}}</h2>
    <p class="font-semibold">You will be automatically redirected. 
    If it doesn't work, follow the <a href="{{url_for('index')}}">link</a></p>
    {% endblock %}
    </div>
</body>
</html>

We can execute this script from the terminal by typing:

$ python3 FeedbackForm.py

Now, we need to open localhost:5000 on our favourite browser.

NOTE: If you are using Flask on a Mac that has Monterey or higher, you may have trouble accessing localhost. You can solve this by disabling the Airplay Receiver in your Sharing folder. (Airplay Receiver uses port 5000.) Follow these instructions: How to disable Airplay Receiver.

Once we hit submit, we will get instant feedback.

We use redirection, so it will go back to the main page after 5 seconds. And here we’re displaying the information entered by the user.

If we check our mailbox, we will find this:

We have all the information we need on this email. So we’re ready for the next stage.

Creating a Python script

In this step, we’re going to read all the emails with the label “VeggiEggs”, in order to analyze them with the Sentiment Analysis endpoint as well as to gather important information like the rating and the date the email was sent.

We’re going to create a file called NeuralFeeback.py. It looks like this:

# Load your env variables
from dotenv import load_dotenv
load_dotenv()

# Import your dependencies
import os
from nylas import APIClient
import subprocess

# Initialize your Nylas API client
nylas = APIClient(
    os.environ.get("CLIENT_ID"),
    os.environ.get("CLIENT_SECRET"),
    os.environ.get("ACCESS_TOKEN"),
)

# Gather all messages from the label “VeggiEggs”
messages = nylas.messages.where(in_="VeggiEggs")
# Create variables to hold the information to be passed to R
rating = []
sentiment = []
score = []
date = []
sRating = ""
sSentiment = ""
sScore = ""
sDate = ""

# Read all messages
for message in messages:
# Split the title in order to get the rating value
    line = message.subject.split(" - ")
    rating.append(line[3])
# Send each message to the Sentiment Analysis endpoint
    message_analysis = nylas.neural.sentiment_analysis_message([message.id])
# Extract the Sentiment Analysis result
    sentiment.append(message_analysis[0].sentiment)
    score.append(str(message_analysis[0].sentiment_score))
    date.append(str(message.received_at.date()))    

# Turn the information into a long string separated by commas
sRating = ','.join(rating)
sSentiment = ','.join(sentiment)
sScore = ','.join(score)
sDate = ','.join(date)

# We want to know when R is getting called
print("Calling R")
# Call R as a subprocess and launch Shiny in the browser
subprocess.run(["RScript", "-e", "shiny::runApp('<path_to_your_python_env>', launch.browser = TRUE)", sRating, sSentiment, sScore, sDate])

Setting up R

Installing R

As we’re going to use Shiny to create our dashboard, we need to create a R script. If you don’t have R installed on your computer you can do it like this.

Here’s the latest version of R for the Mac R-4.1.3. Also, while optional, we need to install XQuartz as it is not bundled with Mac by default.

Installing RStudio

While it’s not mandatory, we should install RStudio which is by far the best R IDE.

Installing the necessary packages

We will need to install some packages in order to have our Shiny application running. Open up RStudio and click on “Tools → Install packages”. Type the following packages separated by a comma:

shiny → Makes it incredibly easy to build interactive web applications with R

tidyverse → The tidyverse is an opinionated collection of R packages designed for data science

treemap → Displays hierarchical data as a set of nested rectangles

imager → Fast image processing for images in up to 4 dimensions

plyr → Tools for Splitting, Applying and Combining Data

We need to make sure to leave “Install dependencies” checked and press Install.

Once everything is installed, we can create the script.

Creating the Shiny script

We need to press File → New → R Script and save the file as App.r then type the following

# Load packages
library("shiny")
library("tidyverse")
library("treemap")
library("imager")
library("plyr")

# UI Section of our Shiny app
ui <- fluidPage(
# Dashboard headline
  tags$div(
    HTML("<h1 style='color:blue;text-align:center;'>VeggiEggs Dashboard!</h1>")
  ),  
# Dashboard title
  title = "VeggiEggs Dashboard!",
# Define how our plots are going to be laid off
                 fluidRow(
                   column(width=5, plotOutput(outputId = "distPlot")),
                   column(width=5,offset=2, plotOutput(outputId = "distPlot2"))
                 ),
                 fluidRow(
                   column(width=5, plotOutput(outputId = "distPlot3")),
                   column(width=5,offset=2, plotOutput(outputId = "distPlot4"))
                 )) 

# Server part, here is where the plots are defined
server <- function(input, output) {

# We receive the information coming from Python
  args = commandArgs(trailingOnly=TRUE)
  ratings<-as.integer(strsplit(args[1], ",")[[1]])
  sentiments<-strsplit(args[2], ",")[[1]]
  scores<-as.integer(strsplit(args[3], ",")[[1]])    
  dates<-as.Date(strsplit(args[4], ",")[[1]])

# We create a Data.Frame to better handle the data
  entries = data.frame(ratings, sentiments, scores, dates=as.Date(dates))  

# First plot. Summarize the ratings
  output$distPlot <- renderPlot({
    Ratings <- count(entries, 'ratings')
    names(Ratings)<-c("Ratings","Count")
    Count <- Ratings$Count
    Ratings %>%
      ggplot( aes(x = Ratings, y = Count, fill = Count)) + 
        geom_bar(stat="identity")
  })

# Second plot. How many feedbacks per day
  output$distPlot2 <- renderPlot({
    Freq <- count(entries, 'dates')
    names(Freq)<-c("Dates","Entries")
    Freq %>% 
      ggplot( aes(x=Dates, y=Entries)) +
      geom_line(color="green") +
      geom_point()
  })

# Third plot. Frequency of sentiment analysis
  output$distPlot3 <- renderPlot({
    Sentiment <- count(sentiments)
    group <- paste(Sentiment$x,Sentiment$freq)
    sentiment<-Sentiment$freq
    data <- data.frame(group,sentiment)
    treemap(data,
            index="group",
            vSize="sentiment",
            type="index"
    )
  })

# Fourth Plot. Display an image for each score range  
  output$distPlot4 <- renderPlot({
    Score<-mean(entries$scores)
    if (Score < -0.5){
      image_filename<-"angry-emoji.png"
    }
    if (Score > -0.5 && Score < 0.5){
      image_filename<-"neutral-emoji.png"
    }
    if (Score > 0.5){
      image_filename<-"happy-emoji.jpeg"
    }

    image <- load.image(image_filename)
    plot(image)
  })

}

shinyApp(ui = ui, server = server)

As we are calling this script from Python, there’s nothing more to do here.

Here are the images we’re using, and they need to be in the same folder as our script.

Calling the Dashboard

In order to call the Dashboard, the only thing we need to do is run our Python script by typing this into the terminal window:

$ python3 NeuralFeedback.py

The Dashboard will be opened automatically on the default browser.

That’s it. Hope you like this post! You can get more information on Sentiment Analysis on the Nylas Documentation page.

Join our technical demo to see the Nylas Platform in action

What is Nylas, why did I join and why should you care?

Alvaro (Blag) Tejada Galindo — Wed, 18 May 2022 10:40:46 +0000

This post was originally posted on LinkedIn What is Nylas, why did I join and why should you care?

I joined Nylas around four months ago as their first Senior Developer Advocate. It might seem like a short amount of time, but in the startup world, time moves differently.

What is Nylas?

In a nutshell, Nylas is a set of APIs that allows you to easily connect with any email, calendar and contacts provider without having to go through a lengthy and complex configuration process.

In other words, we do the heavy work so you can focus on your business.

When it comes to Email, we offer “One Email API for Every Provider”. This means our Email API is universal, and you can connect to various providers without having to write specific code for each. Also, we provide real-time, bi-directional sync, and full CRUD capabilities. If you want to learn more, just go to our Universal Email API page.

When it comes to Calendar, we offer the same capabilities as our Email API, but also conferencing sync, events metadata, and programmatic webhooks. If you want to learn more, just go to our Universal Calendar API page.

When it comes to Contacts, you can create, update or delete contacts in any supported provider. If you want to learn more, just go to our Universal Contacts API page.

With Email, Calendar, and Contacts APIs, we’re just getting started. Check out what we offer on top of these APIs to give developers even more power.

With Neural API, exploring the world of AI and ML is easy, with ready-made models that can be used to clean conversations, extract signatures, perform OCR, and run sentiment analysis. If you want to learn more, just go to our Neural API page.

Nylas Streams is our ETL solution that requires little to no code to transform and consume communications data for E-Commerce, Sales, Fintech and Customer Success. If you want to learn more, just go to our Nylas Streams page.

Scheduler, a full-featured scheduler with customizable UI. If you want to learn, just go to Scheduler.

Components, ready-made and fully flexible UI/UX widgets ready for immediate use. If you want to learn more, just go to Components.

Why did I join?

The first thing that caught my attention with Nylas was the fact that they provide APIs to make communications easier. Handling Email, Calendars and Contacts gives a lot of space to create amazing applications.

The second thing that attracted me to Nylas was the company culture. Everybody looked committed to each other, as I saw a lot of internal support when the Nylas account posted something on social media, and also my interviews were more like chatting with friends than actual interviews.

The third and probably most important thing for me, was going back to Developer Advocacy, which is something that I’m really passionate about. Being able to share with the community is something that makes me feel good and that makes me a better person and a better developer.

Obviously, those 3 things might not be enough to convince you, so let’s create a small example.

For this, I’m going to choose one of my favourite Programming Languages– R. And while I’m not an R professional or expert, I’m very passionate about it, so bear with me, there might be better ways to do this.

What we are going to do is simply read the first three messages in my inbox and print the subjects.

The result is going to be:

A Nylas email

Invitation: RRSP Webinar @ Tue Feb 8, 2022 1pm - 2pm (EST) (alvaro.t@nylas.com) 

Start here: Welcome to Clockwise

Obviously, while R is an awesome language used by statisticians and data scientists around the world, it is not a mainstream language.

That’s why Nylas provides us with SDKs for Python, Ruby, Node, and Java.

Let’s see how we can read our inbox using the Python SDK. If you want to learn how to install the SDK, read our Python Documentation.

The result is going to be:

A Nylas email

Invitation: RRSP Webinar @ Tue Feb 8, 2022 1pm - 2pm (EST) (alvaro.t@nylas.com) 

Start here: Welcome to Clockwise

As you can see, using the SDK is easier, because we don’t need to traverse the JSON response or figure out where the element that we want to print is. Also, if something changes internally we can rest assured that the SDK will be updated to reflect any changes while simply calling the API will require some manual work. And the same goes for Calendar, Contacts, and the rest of our offerings.

Why should you care?

Well, to begin with, I’m your friendly Developer Advocate so you know I’m going to provide you with constant and interesting content about the Nylas APIs. Also, signing up for a Nylas account is easy, no Credit Card is required and you can get 14 days to try it out. Ready to go? Just go to https://dashboard.nylas.com/register and follow the instructions.

Also, I’m already working on a series of blog posts that will help you to get started, make your first API calls and in overall, get the full Nylas experience.

You can start by reading my blog How to Send Emails with the Nylas Python SDK

Don’t think Nylas is for you? Well, recommend us to a friend then. You might know someone who could benefit from having fast, easy, and convenient access to universal communication APIs.

5 not well known Programming Language that are worth exploring

Alvaro (Blag) Tejada Galindo — Wed, 02 Feb 2022 17:08:19 +0000

Just because you don't know them...doesn't mean they are not good Programming Languages...

I already talked about Old Programming Languages on 5 old Programming Languages you should know about and 5 old Programming Languages you might want to be aware of, so this time let's talk about Programming Languages that not that well known, but that you might find really interesting to work with...

To illustrate how those programming work, we're to use a very basic app called "Fibonacci List" which will simply output a list of requested Fibonacci numbers, for example if we ask for 5, it should return 0, 1, 1, 2, 3, 5.

Let's start our list with

Mercury (1995)

Mercury is a Logical/Functional Programming Language. It looks like Prolog, but feels like strict Haskell or pure OCalm.

On Linux, you can download the source from here and simply do

./CONFIGURE --> MAKE --> MAKE INSTALL

:- module fibonacci.
:- interface.
:- import_module io.

:- pred main(io::di, io::uo) is det.

:- implementation.
:- import_module string, int.
:- pred fibo(int::in, int::in, int::in, string::out) is det.

fibo(Num, A, B, Fibs) :-
    (   
        if A = 0 
        then fibo(Num-1,A+B,B,Fib), 
             Fibs = int_to_string(A) ++ " " ++ 
             int_to_string(B) ++ " " ++ 
             int_to_string(A+B) ++ " " ++ Fib
        else if A > 0, Num > 1
        then fibo(Num-1,A+B,A,Fib), 
             Fibs = int_to_string(A+B) ++ " " ++ Fib
        else Fibs = ""
    ).


main(!IO) :-
    io.write_string("Enter a number: ",!IO),  
    io.read_line_as_string(Result, !IO),    
    (   if    
            Result = ok(String),            
            string.to_int(string.strip(String), N)            
        then        
            fibo(N,0,1,Fibs),            
            io.write_string(Fibs,!IO)            
        else        
            io.write_string("Not a number...",!IO)            
    ).

In order to run this, we need to compile it first by using

mmc --make -E name_of_file.m

You can read my Mercury Introduction here.

Falcon (2001)

Multiparadigm Programming Languages, supporting Procedural, Object Oriented, Prototype-based, Functional, Tabular and Message passing.

It should be already available on most Linux distributions, but if not you grab it from here.

It's syntax is fairly similar to many other programming languages, so it should be easy to pick up.

function fib(num,a,b)
    result = ""
    if a > 0 and num > 1
        result = result + (a+b) + " " +  
                 fib(num-1,a+b,a)       
    elif a == 0 
        result = "" + a + " " + b + " " +       
                 (a+b) + " " + fib(num-1,a+b,b)     
    end 
    return result   
end

print("Enter a number: ")
num = int( input() )
print(fib(num,0,1))
printl("")

In order to run simply type

falcon name_of_file.fal

You can read my Falcon introduction here.

Dao (2004)

Lightweight and optionally typed Programming Language. The author created out of frustration with Perl.

You can download the source code and extract it.

Then type

make -f Makefile.daomake PLATFORM

Where PLATFORM can be linux, macos, mingw and more...

Finally, run

make install

routine fib(num :int, a :int, b :int){
  var result = ""
  if (a > 0 and num > 1){
    result = result + " " + (string)(a + b) + 
             fib(num - 1, a + b, a)
  }else if (a == 0) {
    result = (string)a + " " + (string)b + " " + 
             (string)(a + b) + fib(num - 1, a + b, b)
  }
  return result
}

io.write('Enter a number: ')
invar num = io.read()
io.writeln(fib((int)num, 0, 1))

To run this, simply type

dao name_of_file.dao

You can read my Dao Introduction here.

Factor (2003)

A Stack-Oriented Programming Language, based on Forth and Lisp.

If you like Forth, you will love Factor.

To install, simply go to the Factor Homepage and download the binary. Then run it.

You will get a listener and that's where you application will be executed.

Type the following on the Listener.

USE: tools.scaffold

"fibo" scaffold-work  ! You might get an error saying 
                      ! that "fibo" doesn't exist...
                      ! ignore that -:)

This will create a "fibo" folder inside the "work" folder inside your Factor installation folder.

Then edit the "fibo.factor" file that was generated.

! Copyright (C) 2018 Blag.
! See http://factorcode.org/license.txt for BSD license.
USING: math prettyprint kernel io math.parser command-line 
       namespaces sequences ;
IN: fibo

<PRIVATE
: ask-number ( -- ) "Enter a number: " print ;
: read-number ( -- n ) readln string>number ;
: list_fibo ( x -- )
 1 0
 pick 1 + [ dup . over over + rot drop ] times 3drop ;
PRIVATE>

: fibo ( -- ) ask-number read-number list_fibo ;
: fibo-run ( -- ) fibo ;
MAIN: fibo-run

On the Listener type

fibo run

You can read my Factor Introduction here.

io (2002)

Pure, dynamic, concurrent and accessible Programming Language. Inspired by Smalltalk, Self, NewtonScript, Act, Lisp and Lua.

To install it just follow the instructions on IO's Github.

#This method needs to go in one line...

fib := method(num,a,b,result, 
       if(a > 0 and num > 1) 
       then(result = result .. (a+b) .. " " .. 
            fib(num-1,a+b,a,result)) 
       elseif(a == 0) 
       then(result = a .. " " .. b .. " " .. 
            (a+b) .. " " .. fib(num-1,a+b,b,result)); 
            return result)


"Enter a number: " print
number := ReadLine readLine
fib(number asNumber,0,1,"") println

To run this simply do

io name_of_file.io

You can read my IO Introduction here.

Hope you try some...and see you next time -:)

5 old Programming Languages you might want to be aware of

Alvaro (Blag) Tejada Galindo — Tue, 25 Jan 2022 19:19:19 +0000

Learning from the past can help you look into the future.

As my post 5 old Programming Languages you should know about was successful so I decided to keep going...

This time I want to share some old programming languages that might not be so "well known" but that are still important pieces of the history of programming...

To illustrate how those programming languages work, we're to use a very basic app called "Fibonacci List" which will simply output a list of requested Fibonacci numbers, for example if we ask for 5, it should return 0, 1, 1, 2, 3, 5.
We used before, so why not used it here again...

We're not going in order this time...

Miranda (1985)

Lazy, purely functional programming language.

fib :: (num, num, num) ->  [char]
fib(num,a,b) = show(a+b) ++ " " ++ 
               fib((num - 1),(a+b),a), if(a > 0 & num > 1)
             = show(a) ++ " " ++ show(b) ++         
               " " ++ show(a+b) ++ " " ++                
               fib((num - 1),(a+b),b), if(a == 0)
             = [], otherwise

showFib :: num -> [char]
showFib num = "\n" ++  fib(num, 0, 1) ++ "\n"

Let's see...Miranda doesn't have variables, arrays, tables or dictionaries...so lists are your best friends...doesn't have loops so recursion is a must...
It was a major inspiration for Haskell.

Compilers are available here.
To run it we do...

mira name_of_file.m

And then call the main function with its corresponding parameter

showFib 5

You can read my Miranda introduction here.

Rexx (Restructured Extended Executor - 1979)

Multiparadigm, procedural, structured and interpreted programming language, but also scripting and macro.
It is considered the very first Scripting Language.

say "Enter a number: "
pull number .
say ""
call fibo number, 0, 1
say
exit 0

if a = 0 then
    do
        a_b = a + b
        call charout, (a b a_b)
        call charout, " "
        call fibo num - 1, a + b, b
    end
else if a > 0 & num > 1 then
   do
        a_b = a + b
        call charout, a_b
        call charout, " "
        call fibo num - 1, a + b, a
    end
return

There are no arrays in Rexx...we call them compounds. We have functions and subroutines, as well as some sort of stack. It's actually pretty fun to use...

On Linux, we can get the compiler as easy as doing this...

sudo apt-get install -y regina-rexx

For other platforms, go here.

To run we simply do this

regina name_of_file.rexx

You can read my Rexx introduction here.

Icon (1977)

Very high-level programming language featuring goal-directed execution.

procedure fib(num, a, b)
    local result
    result := ""    
    if a > 0 & num > 1 then    
        result := result || " " || (a + b) ||         
                  fib(num - 1, a + b, a)        
    else if a = 0 then    
        result := a || " " || b || " " ||         
                  (a + b) || fib(num - 1, a + b, b)        
    return result    
end

procedure main()
    local num 
    write("Enter a number: ") 
    num := read() 
    write(" ") 
    write(fib(num, 0, 1))
end

There's not data type declaration...as it changes according to its value. An operations can success or fail...which prevents crashes. Icon doesn't have arrays, but lists, records and tables and list can be composed of different data types.

You can download Icon from here.

And follow these instructions to compile it.

To run our app we simply need to call it like this

icon name_of_file.icn

You can read my Icon introduction here.

Prolog (Programming Logic - 1972)

General purpose logic programming language associated with artificial intelligence and computational linguistics.

fibo(NUM,A,B,[H|T]) :- (NUM > 1 -> H is A + B, X is NUM - 1, 
                        (A =:= 0 -> fibo(X,H,B,T); fibo(X,H,A,T))).
fibo(_,_,_,[]).

fibonacci(NUM,R) :- fibo(NUM,0,1,X), !, append([0,1], X, R).

Prolog is declarative and the program logic is expressed in terms of relations, represented as facts and rules. Recursion is a key component of Prolog.

For this I'm using swi-prolog because it's free and widely used.

To run this example, simply do this

swipl

And the call our filename like this...

[fibonacci].

Then, call the main function like this...

fibonacci(5,X).

You can read my Prolog introduction here.

And least but not last...

Forth (1970)

Imperative stack-based programming language and programming environment.

: FIBO 
   1 SWAP 
   0 DUP . 
   ?DO 
      DUP . OVER OVER + ROT DROP 
   LOOP 
   DROP DEPTH 
   DEPTH 2 = IF 2DROP 0 THEN ;

As we manipulate the stack, we use LIFO (Last In, First Out). There's a lot of functions to help us with the stack, like duplicate, rotate, swap and so on...

If you're using Linux, simply do this...

sudo apt-get install pforth

If you're using Windows then go here.

In order to run this example simply call

pforth

And once inside the environment

INCLUDE name_of_file.fth

You can read my Forth introduction here.

That's it...I hope you like this post and next one coming should be 5 not well known Programming Language that are worth exploring.

Blag.

5 old Programming Languages you should know about

Alvaro (Blag) Tejada Galindo — Fri, 21 Jan 2022 14:32:11 +0000

This post was originally posted on LinkedIn.

For some people, old programming languages are ugly, obsolete, old-fashioned and useless. For me, they're the complete opposite...gems waiting to be rediscovered.

An old programming language can teach you a lot and can make you for sure a better developer. People today are getting used to have everything provided by the language and that's bad because it doesn't force you to think. Old programming language lack a lot of things that you find in modern languages, but that doesn't mean they're not as powerful, as they provide you all the tools to implement things yourself.

Let's start with the oldest programming language I know...

FORTRAN (Formula Translator - 1957)

A general-purpose, imperative programming language that is essentially suited to numeric computations and scientific computing.

program fibonacci

  implicit none
  integer :: a=0, b=1, num
  write(*,'(a)',advance="no") "Enter a number: "
  read(*,*) num
  write(*,*) trim(fib(num, a, b))

contains

recursive function fib(num, a, b) result(fibo)

  integer, intent(in) :: num, a, b
  integer :: ab
  character(1000) :: a_s, b_s, ab_s
  character(1000) :: fibo

  if(a > 0 .and. num > 1) then
    ab = a + b
    write(ab_s, '(I0)') ab
    fibo = trim(ab_s) // " " // fib(num - 1, ab, a)
  else if (a == 0) then
    ab = a + b
    write(a_s, '(I0)') a
    write(b_s, '(I0)') b
    write(ab_s, '(I0)') ab
    fibo = trim(a_s) // " " // trim(b_s) // " " // 
           trim(ab_s) // " " // trim(fib(num - 1, ab, b))
  else
    fibo = ""
  end if

  return
end function fib

end program fibonacci

Let's see...A program must be enclosed between "program" and "end program" tag. Variables need a type when they are declared. A recursive function must be labeled as "recursive". String variables are fixed in length. "//" is used to concatenate. Integers and Character can be concatenated together without further transformations. We need to trim a lot to avoid extra space due to the really long fixed size. Functions can return zero, one or multiple values.

To compile this...I used GFORTRAN which come with Linux, but can be simply installed by doing "sudo apt-get install gfortran". Being a GNU App...this is not a real Fortran compiler...it's written in C.

GFORTRAN -WALL -C "NAME_OF_FILE.F95"
GFORTRAN -WALL -O "NAME_OF_EXEC" "NAME_OF_FILE.F95"

You can read my FORTRAN Introduction here.

Cobol (Common Object Business Oriented Language - 1959)

A compiled English-like computer programming language designed for business use.

It's imperative, procedural and since 2002, Object Oriented.

IDENTIFICATION DIVISION.
PROGRAM-ID. fibonacci.
ENVIRONMENT DIVISION.
DATA DIVISION.
WORKING-STORAGE SECTION.
    01 USER-NUMBER      PIC 9(3).
    01 A                PIC 9(3).
    01 B                PIC 9(3).
    01 AB               PIC 9(3).
    01 COUNTER          PIC 9(3).   
    01 COUNTER-SPACES   PIC 9(3).

PROCEDURE DIVISION.
PROGRAM-BEGIN.
    MOVE 0 TO A.
    MOVE 1 TO B.
    DISPLAY "Enter a number: ".
    ACCEPT USER-NUMBER.
    PERFORM GET-FIBO WITH TEST AFTER UNTIL USER-NUMBER = 1.
    DISPLAY " ".

PROGRAM-DONE.
STOP RUN.

GET-FIBO.
    IF A = 0
        COMPUTE AB = A + B
        INSPECT AB TALLYING COUNTER FOR CHARACTERS
        INSPECT AB TALLYING COUNTER-SPACES FOR LEADING ZEROS
        COMPUTE COUNTER-SPACES = COUNTER-SPACES - COUNTER
        DISPLAY 0 " " 1 " " AB(COUNTER:COUNTER-SPACES) WITH NO ADVANCING
        COMPUTE USER-NUMBER = USER-NUMBER - 1
        MOVE AB TO A
    ELSE
        MOVE 0 TO COUNTER
        MOVE 0 TO COUNTER-SPACES        
        COMPUTE AB = A + B
        INSPECT AB TALLYING COUNTER FOR CHARACTERS
        INSPECT AB TALLYING COUNTER-SPACES FOR LEADING ZEROS
        IF COUNTER-SPACES = 0
            DISPLAY " " AB WITH NO ADVANCING
        END-IF
        IF COUNTER-SPACES = 1
            COMPUTE COUNTER = COUNTER - COUNTER-SPACES
            DISPLAY " " AB(COUNTER:COUNTER) WITH NO ADVANCING
        END-IF
        IF COUNTER-SPACES = 2
            COMPUTE COUNTER-SPACES = COUNTER-SPACES - COUNTER
            DISPLAY " " AB(COUNTER:COUNTER-SPACES) WITH NO ADVANCING
        END-IF
        COMPUTE USER-NUMBER = USER-NUMBER - 1
        MOVE A TO B
        MOVE AB TO A
    END-IF.

As we can see...Cobol is very strict...it has "divisions" and "sections". Variables need to be declared first and cannot be declared anywhere else outside it's section. Moving a value into a variable is not the same as assigning a value to a variable. There is no such thing as IF-ELSE. You can inspect a variable to get its length or amount of zeros.

I know you're wondering what the heck "PIC 9" means...well..."9" is for numeric values, "X" for alphanumeric, "S" for sign and "V" for decimals.

To compile this...I used Open-Cobol that can be simply installed by doing "sudo apt-get install open-cobol". Being a GNU App...this is not a real Cobol compiler...it's written in C.

COBC -X -FREE -O "NAME_OF_FILE" "NAME_OF_FILE.COB"

You can read my Cobol Introduction here.

Simula (Simulation Programming Language - 1962)

Superset of Algol 60. Consired the first Object Oriented programming language.

begin
    integer num;
    text result;

    procedure fib(num, a, b);
    integer num, a, b;
    begin
        if a > 0 and num > 1 then
            begin
                OutInt(a+b,3);
                fib(num - 1, a + b, a);         
            end;
        if a = 0 then
            begin
                OutInt(a,3);
                OutInt(b,3);
                OutInt(a+b,3);
                fib(num - 1, a + b, b);
            end;    
    end;

    OutText("Enter a number: ");
    OutImage;
    num := InInt;
    fib(num,0,1)
    OutImage;
end

Every program start with a "Begin - End". Variables need a type. We can have global and local variables. "OutInt" is used to print Integers on the screen while "OutText" is for strings. OutImage is used to print an empty line. Integer variables are assigned using "=" while String variables use ":=".

To compile, I used GNU CIM which is a transpiler from Simula to C. You can install it from here.

cim "NAME_OF_FILE.cim"

You can read my Simula Introduction here.

Snobol (String Oriented and Symbolic Language - 1967)

Imperative and Unstructured programming Language. Also, it's goal oriented.

* Fibonacci Sequence

        define('fibo(num,a,b)temp','fib')       :(fibo_end)
fib     fibo = eq(a,0)  a ' ' b ' ' ( a + b )   
        num = num - 1   
        a = a + b                               :s(fib0)
fib0    gt(num,1)                               :s(fib1)f(return)
fib1    fibo = gt(a,0) fibo ' ' ( a + b )       
        num = num - 1   
        temp = a                        
        a = a + b                               
        b = temp                                :s(fib0)f(return)
fibo_end

        output = 'Enter a number: '
        num = input
        output = fibo(num,0,1)
end

Variables doesn't need a data type, it's type depend on the assigned value. When defining a method we need to specify what to call when it ends or fails. For each section we need to determine if it works or not and depending on that move to another section. An "If" condition needs to be by itself and move to other section depending on the result. In this example "gt(num,1)" is an "If" statement.

To compile we need to first build the compiler...which is by the way a C app.

WGET FTP://FTP.ULTIMATE.COM/SNOBOL/SNOBOL4-1.5.TAR.GZ
TAR –ZXVF SNOBOL4-1.5.TAR.GZ && CD SNOBOL4-1.5
SUDO APT-GET INSTALL M4
SUDO MAKE INSTALL

To run we need to do...

snobol "NAME_OF_FILE.sno"

You can read my Snobol Introduction here.

Algol68 (Algorithmic Language - 1968)

Part of the Algol family of imperative programming Languages (Algol58, Algol60 and Algol68). One of the most influential languages of all time, giving rise to Simula, B, Pascal and C amongst many others.

BEGIN
    print("Enter a number: ");
    INT num = read int;

    PROC fib = (INT num, a, b)VOID:
        IF a > 0 THEN
            IF num > 1 THEN
                printf(($g(0)x$, a + b));
                fib(num-1, a+b, a)
            FI
        ELIF a = 0 THEN
            printf(($g(0)x$, a + b));
            fib(num-1, a+b, b)
        FI;

    printf(($g(0)x$, 0, 1));    
    fib(num,0,1);
    print(newline)
END

All applications start with a BEGIN-END. Variables need a type. Procedures can have zero or more parameters. The last value is returned and a value must be always returned. When printing a number, the sign will be displayed, that's why we need to format its output. This one most likely the first programming language to use "ELIF", and also "FI" to close an "IF" statement. ";" is used to end a line.

To compile, we need to first install Algol68Genie

SUDO APT-GET INSTALL -Y ALGOL68G

Then we can simply do...

a68g "NAME_OF_FILE.a68g"

You can read my Algol68 Introduction here.

Bonus Section

I know...five is not enough...so why not include a bonus language...one that always interested me as the name seems kind of weird for a programming language -;)

Smalltalk (1972)

An object-oriented, dynamically typed reflective programming language.

Smalltalk had influenced many languages like Objective-C, Java, Python, Ruby and many more...

| number fib result |

result := ''.

fib := [:num :a :b |

    a > 0 & (num asNumber > 1) ifTrue: [
        result := result , (a + b) asString , ' ' , 
                  (fib value: (num asNumber - 1) value: (a + b) value: a).
    ] ifFalse: [
        a = 0 ifTrue: [
            result := a asString , ' ' , b asString , ' ' , (a + b) asString , ' ' , 
            (fib value: (num asNumber - 1) value: (a + b) value: b).
        ]. 
    ].
].

Transcript show: 'Enter a number: '.
num := stdin nextLine.

Transcript show: (fib value: num value: 0 value: 1); cr.

Variables are declared between "|". Values are assigned using ":=". "IF" statements are special as they are defined as "ifTrue" and "ifFalse" and "[ ]" are used to enclosed blocks. We use "Transcript show" because otherwise a text will be printed enclosed like this 'This is a text' instead of This is a text. If you wonder about "value:", that's used to call a parameter.

To compile, we're going to use GNU Smalltalk, that can be installed like this

sudo apt-get install gnu-smalltalk

and them simply...

gst "NAME_OF_FILE.st"

You can read my Smalltalk Introduction here.

That's it -:) Hope you had some fun -;) I had a lot of fun learning them...and they surely made me a better developer...and yes...I frustrated me plenty of times...but that's the fun of programming -;)

Blag.