DEV Community: aidelojep

Building a Task Management Application using Rest API, Spring Boot, Maven and Fauna

aidelojep — Tue, 30 Nov 2021 06:48:00 +0000

Written in connection with the Write with Fauna Program.

This article focuses on the tutorial steps in building a Rest API using the Java Programming framework (Spring Boot), Maven, and Fauna. We used Fauna as our database to save our information and integrated this into our Spring Boot project. We also outlined these steps to make it easy for beginners to follow through and implement the same using these steps when working on a similar project.
The Rest API is more suitable for server-side API rendering. Hence, the REST API is a valuable architectural style for microservices because of its simplicity, scalability and flexibility. In microservice architecture, each application is designed as an independent service from the other. We recall that microservices rely on small teams to deploy and scale their respective services independently, this makes the REST API an invaluable resource to this architectural style.

Prerequisites

To fully understand this part of the tutorial, you are required to have the following:

Fundamental knowledge of how to program with Java.
At least fundamental knowledge of Spring Framework and Spring Boot.
Java Development Kit(JDK)installed.
Postman installed or click on the link to download and install.
Maven installed or click on the link to download and install.
IntelliJ installed or click on the link to install. You can use any other IDEA of choice.

What is an API?

In the simplest form, an API is the acronym for application programming interface that allows for two or more different applications to talk to each other. Everytime you make use of these applications, the applications on your phone, gadgets or computer connect to the internet and send data to the server. This data retrieved by the server is then interpreted, and some actions are performed and a feedback is sent back to you in a human or readable format. The API also provides a level of security here since each communication entails a small packet of data, the data sharing here only entails that which is necessary. Another additional benefit of RESTful APIs is its Client-Server constraints. This constraint operates on the concept that the client and server side should be separated from each other. This is referred to as separation of concerns which guarantees more efficiency in our application. Therefore, I should be able to make changes on my client side without affecting my database design on the server and vice-versa. This makes our application to be loosely coupled and easily scalable .
This article teaches how to create a SpringBoot and Restful API that performs CRUD (Create, Read, Update and Delete) operations by making a database call to a Fauna. The application we will be building in this tutorial is a “task-management app” for users to manage all their daily tasks.

Key Takeaways

How to create and set up a Spring Boot application with a Tomcat Server.
Fauna database configuration in a Spring Boot Project.
Maven for Dependency management.
Exception Handling in Java.
How to document API using Swagger.

Project Setup

To initialize the project we are going to use spring initializer . Enter the maven project properties of the project including the dependencies as shown below and click on the generate button. This will generate a zip file and download it for you. Unzip it and open it in your favorite IDEA and sync the dependencies with Maven.

For this project we are going to add two dependencies namely:

Spring web: This dependency makes your project a web application. The spring-boot-starter-web dependency transitively pulls in all dependencies related to Web development using Spring MVC, REST, and Tomcat as a default embedded server.
Spring Data JPA: This allows us to persist data in SQL databases using Spring Data and Hibernate which is an implementation of the JPA. JPA stands for Java Persistent API, it is a specification that is part of Java EE (Enterprise Edition) and defines an API for Object-Relational Mappings (ORM) and for managing persistent objects and Relational Databases. It is considered a standard approach for Object Relational Mapping. Being that JPA is a specification, it does not perform any operation by itself, as such requires implementation. Hibernate is one of those ORM (Object Relational Mapping) tools that implements JPA. Others include TopLink, MyBatis.

The EntryPoint of the Application

The beauty of SpringBoot lies in how easy it is to create stand-alone, production-grade spring-based applications that you can "just run". If you open your TaskManagerApplication.java file.



package com.taskVentures.taskmanager;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;

@SpringBootApplication
public class TaskmanagerApplication {

  public static void main(String[] args) {
    SpringApplication.run(TaskmanagerApplication.class, args);
  }

}

SpringBoot applications should have an entry point class with the public static void main(String[] args) methods, which is annotated with the @SpringBootApplication annotation and will be used to bootstrap the application. It is the main method which is the entry point of the JVM to run our application.
The @SpringBootApplication annotation informs the Spring framework, when launched, to scan for Spring components inside this package and register them. It also tells Spring Boot to enable Autoconfiguration, a process where beans are automatically created based on classpath settings, property settings, and other factors. The @SpringBootApplication annotation has composed functionality from three annotations namely @EnableAutoConfiguration,@ComponentScan, and @Configuration. So we can say it is the shortcut for the three annotations.

Now, we can now run our application. We can do this by either clicking on the play button on our IDEA or running this command: mvn spring-boot:run on our command line. Navigate to the root of the project via the command line and execute the command. Boom! Tomcat started on port 8081 which is the port we configured our application to run.

Maven as a dependency management tool.

The pom.xml file houses the dependencies, Maven plugins in our project.
The dependency section simply contains the dependencies we added to our project namely SpringWeb and springfox for documenting our api.



<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.taskVentures</groupId>
    <artifactId>taskmanager</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>taskmanager</name>
    <description>A web application that individual to manage their daily task.</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
      <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-boot-starter</artifactId>
        <version>3.0.0</version>
    </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies> 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

Adding Additional Maven Dependencies

In this section we are going to add additional deficiencies to the project. To do this, we navigate to Maven Repository and search for the Fauna dependency and add it to the dependencies section of the pom.xml file:

Faunadb: A Fauna cloud database dependencies that connect our Java application to Fuana serverless database.
Lombok: A lombok dependency helps us to reduce boiler plate codes.
Sync the newly added dependencies to the application.
The modified pom.xml should like this:



   <!--newly added dependencies-->

 <dependency>
    <groupId>com.faunadb</groupId>
    <artifactId>faunadb-java</artifactId>
    <version>2.10.0</version>
</dependency>

<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.18.20</version>
  <scope>provided</scope>
</dependency>

Next, we can now proceed to create a database on the Fauna dashboard, and generate a server key and configure FaunaClient in the Spring Boot project. To create a database and server key for our SpringBoot project, we are going to register a Fauna account. To do this, click on this link sign up today and ignore if you have one already. After signup, you get a prompt to create a database like the image below:

Here, we named our database as taskmanager_db. In naming your database, always ensure to use a name that is descriptive. Next we are going to generate our Fauna secret key.

Creating a Fauna API Key

To create a Fauna API Key, you would go to your settings on the Fauna sidebar (at the top left of the screen). This Fauna API key is required to connect the database to our Task_Management_App.

The secret keys generated from Fauna are meant to be copied and stored somewhere safe that can be easily retrieved.

Configuring Fauna Client

In the resources folder within the src/main folder, open application.properties file and add the secret key that you have generated.
fauna-db.secret=”your api secret key should be here”
Next we need to create a bean creates a single instance of the configuration with the help of the @Scope annotation and inject our api key using the @value annotation.



@Value("${fauna-db.secret}")
  private String serverKey;
@Bean
@Scope(value = ConfigurableBeanFactory.SCOPE_SINGLETON)
public FaunaClient faunaConfiguration() {
    FaunaClient faunaClient = FaunaClient.builder()
            .withSecret(serverKey)
            .build();

    return faunaClient;
}

Project Structure

Our project will be structured into four subpackages:
Data: This subpackage will house our Data access layer, which will include our Domain and repository.

Service: This is where our business logic will be.
Web: This package will house our controllers.
Exceptions: This is where all our custom exceptions will be. Throwing exceptions is very important in building a resilient system. This structure will ensure that when a client makes a call to access a resource in the application, such client does not have direct access to our database, rather a request is directed to our controller. Our controller calls the right service(the business logic) which then through our repository makes a call to our database. This architecture also ensures the separation of concerns.

Creating The Domain Class

In the data package, create another package called models. Inside the models package, create a class called Task with the following code:



package com.taskVentures.taskmanager.data.models;

import com.faunadb.client.types.FaunaConstructor;
import com.faunadb.client.types.FaunaField;
import lombok.Data;
import lombok.NoArgsConstructor;


@Data
@NoArgsConstructor
public class Task {
    private String id;

    @FaunaField
    private String name;

    @FaunaField
    private String description;

    @FaunaField
    private  boolean isCompleted;

    @FaunaConstructor
    public Task(@FaunaField("id")String id, @FaunaField("name")String name, @FaunaField("description")String description, @FaunaField("isCompleted")boolean isCompleted) {
        this.id = id;
        this.name = name;
        this.description = description;
        this.isCompleted = isCompleted;
    }

}

@FaunaField annotation Makes the instance variable annotated as database column
We have used the @FaunaConstructor annotation to specify our create constructor and give our files values on creation.
@data creates setters and getters for the class.
@NoArgsConstructor annotation creates a no argument constructor.
@AllArgsContructor creates an all argument constructor.

Payloads

Inside the data package, create a package with the name payloads. This package will have two sub-packages “request” and “response” to handle our request payloads and response payloads respectively.

Request payloads

Inside the request package create an EmployeeRequest class with the following code:



package com.taskVentures.taskmanager.data.payloads.requests;

import lombok.Data;

import java.time.LocalDateTime;

@Data
public class TaskRequest {
    @NotNull
    @NotBlank
    private String name;

    @NotNull
    @NotBlank
    private String description;
    private  boolean isCompleted;
}

@notblank and @NotNull : These two annotation checks and validate the fields where they are mapped to ensure the values are not blank and null respectively.

Response payload

Inside the response package create a TaskResponse class with the following code:



package com.taskVentures.taskmanager.data.payloads.response;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class TaskResponse {
    private String message;
}

The above code is simply a POJO (Plain Old Java Object) with one instance variable, a constructor, a mutator(setters), and an accessor(getters).

The Repository

Inside the data package, create a sub-package called a repository. Then create an interface called “TaskRepository” that extends JpaRepository. The JpaRepository is generic so it takes a model class(Type) and the data type of the primary key. Write the following code in the TaskRepository interface.



package com.taskVentures.taskmanager.data.repository;

import com.taskVentures.taskmanager.data.models.Task;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.concurrent.CompletableFuture;

@Repository
public class TaskRepository extends FaunaRepository<Task> {

    public TaskRepository(){
        super(Task.class, "todos", "tasks");
    }

    @Override
    public CompletableFuture<List<Task>> findAll() {
        return null;
    }

}

@Repository makes the interface a bean. It is treated identically to the @Component annotation, therefore it is a specialization of the @Component annotation. Beans are simply Java classes that spring knows.

Next let’s create a class called FaunaRepository that will contain methods that will allow us to perform the CRUD Operation. We are going to first create an interface that will contain these methods. Let's call the interface Repository.



package com.taskVentures.taskmanager.data.repository;

import com.taskVentures.taskmanager.data.models.Task;

import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;

public interface Repository<T extends Task> {

    CompletableFuture<T> save(T entity);

    CompletableFuture<Optional<T>> find(String id);

    CompletableFuture<Optional<T>> remove(String id);
}

We have defined an interface with methods that allow us to save, find, and update a task. ```Java

package com.taskVentures.taskmanager.data.repository;

import com.faunadb.client.FaunaClient;
import com.faunadb.client.errors.NotFoundException;
import com.faunadb.client.query.Expr;
import com.faunadb.client.query.Language;
import com.faunadb.client.types.Value;
import com.taskVentures.taskmanager.data.models.Task;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;

import static com.faunadb.client.query.Language.*;

import java.lang.Class;

public abstract class FaunaRepository implements Repository, IdentityFactory {

@Autowired
protected FaunaClient faunaClient;

protected final Class<T> entityType;
protected final String collectionName;
protected final String collectionIndexName;


protected FaunaRepository(Class<T> entityType, String collectionName, String collectionIndexName) {
    this.entityType = entityType;
    this.collectionName = collectionName;
    this.collectionIndexName = collectionIndexName;
}


@Override
public CompletableFuture<String> nextId() {

    CompletableFuture<String> result =
            faunaClient.query(
                    NewId()
            )
                    .thenApply(value -> value.to(String.class).get());

    return result;
}


@Override
public CompletableFuture<T> save(T entity) {
    CompletableFuture<T> result =
            faunaClient.query(
                    saveQuery(Language.Value(entity.getId()), Value(entity))
            )
                    .thenApply(this::toEntity);

    return result;
}

@Override
public CompletableFuture<Optional<T>> remove(String id) {
    CompletableFuture<T> result =
            faunaClient.query(
                    Select(
                            Value("data"),
                            Delete(Ref(Collection(collectionName), Value(id)))
                    )
            )
                    .thenApply(this::toEntity);

    CompletableFuture<Optional<T>> optionalResult = toOptionalResult(result);

    return optionalResult;
}


@Override
public CompletableFuture<Optional<T>> find(String id) {
    CompletableFuture<T> result =
            faunaClient.query(
                    Select(
                            Value("data"),
                            Get(Ref(Collection(collectionName), Value(id)))
                    )
            )
                    .thenApply(this::toEntity);

    CompletableFuture<Optional<T>> optionalResult = toOptionalResult(result);

    return optionalResult;
}




protected Expr saveQuery(Expr id, Expr data) {
    Expr query =
            Select(
                    Value("data"),
                    If(
                            Exists(Ref(Collection(collectionName), id)),
                            Replace(Ref(Collection(collectionName), id), Obj("data", data)),
                            Create(Ref(Collection(collectionName), id), Obj("data", data))
                    )
            );

    return query;
}

protected T toEntity(Value value) {
    return value.to(entityType).get();
}


protected CompletableFuture<Optional<T>> toOptionalResult(CompletableFuture<T> result) {
    CompletableFuture<Optional<T>> optionalResult =
            result.handle((v, t) -> {
                CompletableFuture<Optional<T>> r = new CompletableFuture<>();
                if(v != null) r.complete(Optional.of(v));
                else if(t != null && t.getCause() instanceof NotFoundException) r.complete(Optional.empty());
                else r.completeExceptionally(t);
                return r;
            }).thenCompose(Function.identity());

    return optionalResult;
}

}

The above class provides an implementation to the methods defined on the interface.
You can look up the Fauna documentation for Java by clicking on this link: [Fauna/JVM doc](https://docs.fauna.com/fauna/current/drivers/jvm)

```Java


package com.taskVentures.taskmanager.data.repository;

import java.util.concurrent.CompletableFuture;

public interface IdentityFactory {

    CompletableFuture<String> nextId();
}

The TaskService

Create a service package under the taskmanager directory. This package is going to house the business logic. We have divided the service into two, an interface where the methods of our business logic will be declared and a concrete class that implements the interface. Create an interface with the name “taskService" with the following code:



package com.taskVentures.taskmanager.services;

import com.taskVentures.taskmanager.data.models.Task;
import com.taskVentures.taskmanager.data.payloads.requests.TaskRequest;

import java.util.Optional;
import java.util.concurrent.CompletableFuture;

@component
public interface TaskService {
    CompletableFuture<Task> createTask(TaskRequest taskRequest);
    CompletableFuture<Optional<Task>> updateTask(String id, TaskRequest taskRequest);
    CompletableFuture<Optional<Task>> deleteTask(String id);
    CompletableFuture<Optional<Task>> getTask(String id);

}

@Component annotation is a shorthand for the @Bean annotation. It registers the TaskService interface as a bean in the application context and makes it accessible during classpath scanning. We created five methods that allow us to create, update, get and delete tasks.

Next, create a TaskServiceImpl class that implements the TaskService interface. Write the following code:



package com.taskVentures.taskmanager.services;

import com.taskVentures.taskmanager.data.models.Task;
import com.taskVentures.taskmanager.data.payloads.requests.TaskRequest;
import com.taskVentures.taskmanager.data.repository.TaskRepository;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.Optional;
import java.util.concurrent.CompletableFuture;

@Service
@AllArgsConstructor
public class TaskServiceImpl  implements  TaskService  {
    private final TaskRepository taskRepository;

    @Override
    public CompletableFuture<Task> createTask(TaskRequest taskRequest) {
        CompletableFuture<Task> newTask = taskRepository.nextId()
                .thenApply(id -> new Task(id, taskRequest.getName(), taskRequest.getDescription(), taskRequest.isCompleted())).thenCompose(taskRepository::save);
     return newTask;
    }

    @Override
    public CompletableFuture<Optional<Task>> getTask(String id) {
        return taskRepository.find(id);
    }

    @Override
    public CompletableFuture<Optional<Task>> updateTask(String id, TaskRequest taskRequest) {
        CompletableFuture<Optional<Task>> result =
                taskRepository.find(id)
                        .thenCompose(optionalTodoEntity ->
                                optionalTodoEntity
                                        .map(todoEntity -> taskRepository.save(new Task(id, taskRequest.getName(), taskRequest.getDescription(),  taskRequest.isCompleted())).thenApply(Optional::of))
                                        .orElseGet(() -> CompletableFuture.completedFuture(Optional.empty())));

        return result;
    }

    @Override
    public CompletableFuture<Optional<Task>> deleteTask(String id) {
        return taskRepository.remove(id);
    }


}

@Service annotation is a specialized form of @Component. With the @Service annotation, the class that is annotated is registered in the application context and accessible during classpath scanning.

The TaskServiceImpl class implemented the TaskService interface by overriding the method and implementing them.
The class throws an exception(ResourceNotFoundException- This is the custom exception class we created that extends RunTimeException) where the Id supplied to get a single task does not exist on the database.

The Controller

Create a package called web under the taskmanager package. This package is going to house the APIs controller. Create an TaskController class with the following code:




package com.taskVentures.taskmanager.web;

import com.taskVentures.taskmanager.data.payloads.requests.TaskRequest;
import com.taskVentures.taskmanager.services.TaskService;
import io.swagger.annotations.ApiResponses;
import lombok.AllArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.concurrent.CompletableFuture;

@RestController
@RequestMapping("/task")
@AllArgsConstructor
@ApiResponses(value = {
        @io.swagger.annotations.ApiResponse(code = 400, message = "This is a bad request, please follow the API documentation for the proper request format"),
        @io.swagger.annotations.ApiResponse(code = 401, message = "Due to security constraints, your access request cannot be authorized"),
        @io.swagger.annotations.ApiResponse(code = 500, message = "The server is down. Please bear with us."),
})
public class TaskController {
    TaskService taskService;

    @PostMapping("/create")
    public CompletableFuture<?> createTask(@RequestBody TaskRequest taskRequest) {
        return taskService.createTask(taskRequest)
                .thenApply(todoEntity -> new ResponseEntity<>(todoEntity, HttpStatus.CREATED));
    }


    @GetMapping("/get/{id}")
    public CompletableFuture<?> getTask(@PathVariable("id") String id) {
        CompletableFuture<ResponseEntity> result =
                taskService.getTask(id)
                        .thenApply(optionalTodoEntity ->
                                optionalTodoEntity
                                        .map(todoEntity -> new ResponseEntity<>(todoEntity, HttpStatus.OK))
                                        .orElseGet(() -> new ResponseEntity<>(HttpStatus.NOT_FOUND))
                        );
        return result;
    }


    @PutMapping("/update/{id}")
    public CompletableFuture<?> updateTask(@PathVariable("id") String id, @RequestBody TaskRequest taskRequest) {
        CompletableFuture<ResponseEntity> result =
                taskService.updateTask(id, taskRequest)
                        .thenApply(optionalTodoEntity ->
                                optionalTodoEntity
                                        .map(todoEntity -> new ResponseEntity<>(todoEntity, HttpStatus.OK))
                                        .orElseGet(() -> new ResponseEntity<>(HttpStatus.NOT_FOUND)
                                        )
                        );
        return result;
    }

    @DeleteMapping(value = "/delete/{id}")
    public CompletableFuture<?> deleteTask(@PathVariable("id")String id) {
        CompletableFuture<ResponseEntity> result =
                taskService.deleteTask(id)
                        .thenApply(optionalTodoEntity ->
                                optionalTodoEntity
                                        .map(todo -> new ResponseEntity<>(todo, HttpStatus.OK))
                                        .orElseGet(() -> new ResponseEntity<>(HttpStatus.NOT_FOUND)
                                        )
                        );
        return result;
    }


}

@RestController: This annotation marks the EmployeeController as an HTTP request handler and allows Spring to recognize it as a RESTful service.
@RequestMapping("/task") annotation sets the base path to the resource endpoints in the controller as /task. Next, we injected the TaskService class.
@GetMapping is a shortcut for @RequestMapping(method = RequestMethod.GET), and is used to map HTTP GET requests to the mapped controller methods. We used it to return all the tasks and a single task.
@PathVariable annotation shows that a method parameter should be bound to a URI template variable.
@PostMapping is a shorthand for @RequestMapping where the method is equal to POST. It is used to map HTTP POST requests to the mapped controller methods.
@RequestBody: This annotation takes care of binding the web request body to the method parameter with the help of the registered HttpMessageConverters. So when you make a POST request to the “/task/add” URL with a Post JSON body, the HttpMessageConverters converts the JSON request body into a Post object and passes it to the createTask method.
@PutMapping is a shorthand for @RequestMapping where the method is equal to PUT. It is used to map HTTP PUT requests to the mapped controller methods.
@DeleteMapping: Using this annotation makes the Mapped controller method to be ready for a delete operation. is a shortcut for @RequestMapping (method = RequestMethod.DELETE).

Documenting your API with Swagger

We already added the io.springfox dependency to the pom.xml. With this dependency we will document the API so that it will be easy for other developers to use it. All is required is to add the following line of code at the class level of our controller as follows:



 @ApiResponses(value = {
        @io.swagger.annotations.ApiResponse(code = 400, message = "This is a bad request, please follow the API documentation for the proper request format"),
        @io.swagger.annotations.ApiResponse(code = 401, message = "Due to security constraints, your access request cannot be authorized"),
        @io.swagger.annotations.ApiResponse(code = 500, message = "The server is down. Please bear with us."),
})

We added the @ApiResponse annotation from swagger at the class level. As simple as this, our APIs are fully documented.
Go to localhost:8081/swagger-ui to access the documentation and test that our APIs are still working properly.
Use the Swagger API document at localhost:8900/swagger-ui to add an employee, get, update and delete an employee.

Conclusion

In this article project, we successfully built a Task Management Application using SpringBoot framework and Maven as our dependency management and build tools. We used Fauna as our Cloud datastore.
Additionally, we learned how to throw exceptions in our application which ensures that our application is fault-tolerant and resilient. We also learned how to document our API using Swagger. You can clone the project from my GitHub via this link: Task_Management_SpringBoot_Project
If you have any questions, don’t hesitate to contact me via any of my socials:

Implementing Bulk SMS Application with Django, Twilio, and Fauna

aidelojep — Tue, 13 Jul 2021 00:48:00 +0000

This article focuses on implementing Bulk SMS API in a web application built with Python framework (Django). We used Twilio to generate the Bulk SMS, and Fauna as the database to save customer information. The value of bulk SMS in marketing campaigns and business cannot be overemphasized. Bulk SMS API’s can be a very reliable means for most companies to reach out to its large pool of customers about a new product, for a new campaign, or to keep them updated (major or minor changes made to) an already existing service/product.

This article will include steps on how to integrate Fauna with your SMS API system. You could also visit Fauna documentation to find out more about systems that are supported.

Brief Introduction to Serverless database

Serverless architecture refers to a system that affords users greater scalability, more flexibility, and quicker time to release, all at a reduced cost. Most developers prefer to use serverless architectures because of its broad range of advantages like:

Freeing up developer resources and affords them the time to concentrate on projects that directly affects the business value as against spending that time on system maintenance
Not having to worry about purchasing and managing traditional backend servers.
It significantly results in a reduction in server cost, because you only pay as you go.

Fauna leads the serverless database as it is amongst the pioneering serverless databases and also the choice for many developers.

Setting Up Your Fauna Database

Create the Fauna Database

STEP 1: FAUNA SETUP

The first thing to do is create the database for our SMS API project in the Fauna dashboard. If you are new to Fauna and yet to create an account, you will be required to do so via the link attached here: Fauna Account Signup

In the Fauna dashboard, click on the “NEW DATABASE” button, provide a database name and click on the “SAVE” button.

Step 2: Collection indexes

To create a collection index, you would need to navigate the collections tab on the Fauna sidebar, then click on the NEW “COLLECTION” button. Next, enter a name for the collection and click on the “SAVE” button. You can decide to rename the collection to any name of your choice. In this article, we named our collection ‘user’.

Step 3: Creating a Fauna API key

To create a Fauna API key, you would have to navigate to security settings on the Fauna sidebar (located at the top left side of the screen). The Fauna API key helps to connect the database to our SMS API app.

The API keys generated from Fauna are secret keys. It is advisable to copy these keys safely and store them somewhere safe that you can easily retrieve back.

Step 4: Integrating Fauna into Django project

Here, we can now attempt to integrate our Python Library with Fauna from the pip. This can also be installed with a single line on the terminal.

After completing the installation of Django and Fauna, the next step is to run a sample code that is in Fauna Python driver documentations: Fauna python driver documentation

We can see from the code above how the Fauna driver connects with the database that generates its API keys.
Let us consider the steps to follow to build our SMS API application in the following subheading.

BUILDING OUR SMS API:

STEPS TO BUILD THE SMS API IN DJANGO FRAMEWORK

The Project (Bulk SMS APP)

This section will guide you to build a simple Bulk SMS sending web application using the Django web framework and implement the database with Fauna. This Bulk SMS app would allow admin users to add a customer and his phone number to the customers' list and select who to send already customized SMS.

Prerequisites

To fully understand this part of the tutorial, you are required to have the following in place:
Python 3.8 or newer and Django 3.0 or newer (if you don’t have one, don’t worry I will walk you through on how to install Python and Django)
Basic understanding of Fauna
Basic understanding of Django
A text editor e.g. PyCharm, Vscode

Install python

To check if python is successfully installed on your system, run the command “python --version” if python is installed, you will get a response as shown below with the version of python installed. If you don’t have python installed go to https://www.python.org/downloads/ select your operating system, and download.

Creating a virtual environment

Before we start, we need to create an isolated virtual environment to not ship our entire system file and dependencies during deployment.This means that the dependencies of other projects will not be included in the dependencies of our current project even though they are all on the same local machine. To do that, we are going to type the following command. Note the name of the virtual environment is “env” and it's just a variable name that can be named anything.

Next, activate the virtual environment by changing the directory to the virtual environment we just created with the name “env,” go into the Scripts folder and run the executable file “activate.”

INSTALL DJANGO

For this project, we are going to use Django, a python web framework built to meet deadlines, while satisfying the tough software requirements.
Django makes building web applications easy, it helps you build an entire Web application from scratch in a matter of hours. With Django you don’t have to struggle with the fuss of web development. It helps you focus on your business logic without needing to reinvent the wheel. It’s free and open source.
To install Django we are using a python package manager by simply running the command “pip install Django.” If Django is installed successfully, you will get the following output:

create a project (sms project)

Next, we will create our project using the command “Django-admin startproject “ command then the name of the project as shown below. Here the name of our project is "smsproject" and it’s just a variable name, you can name it whatever you like, but make sure it is descriptive.

Creating an app

Next, we create an app with the “python manage.py startapp [name of your app]” command. The name of the app for this tutorial is sms app. Again feel free to name it anything of your choice but should be self-descriptive. This helps other developers easily understand what you are working on. Make sure you change the directory to the sms project we created.

Now that we have successfully created our app, we need to add our app to the installed apps. Go to settings.py and add this: “smsapp.app.SmsappConfig”

smsproject/settings.py

Let us run our app to see if we have successfully installed and correctly set up our project. To run, you have to change the directory into your project and run the command “python manage.py runserver.”

As you can see, we have started our development server at http://127.0.01:8000/.

Open your browser and try to access this URL. If everything works fine, you will see the screen below

Next, we install the python phone number fields package to help us hold the phone numbers. The command is: “pip install django-phonenumber-field[phone numbers].” If the installation works, you will get the following output:

Having installed the Django phone number field, we need to add it to the list of our installed apps, and we do that in the settings.py as follows:

Smsproject/settings.py

Next, we will create a model in models.py to store the name and phone number of a customer.

smsapp/models.py

Migrations

In Django, we use migrations to move changes you make to your models (adding a field, deleting a model, etc.) into your database schema. We need to make migrations to our database.

Run the command “python manage.py makemigrations.” Makemigrations are used to create new migrations based on the changes made to the models in a project. The output is as shown below:

Next, we migrate with python manage.py migrate. Migrate is responsible for applying and reapplying migrations.

Next, we need to register our model in our admin:

smsapp/admin.py

Create an admin(a superuser) that will compose and send messages to the customer.
Let's run our server. Go to localhost:8000/admin

Then log in with our username and password. If you log in successfully, you see this:

Add a customer via the admin panel. Unlike the example below, enter a valid phone number so you can verify the message we will send.

name: Peter
phone number: +2347033622204

Twilio Integration

Twilio is a platform as a service company (PaaS) that provides Cloud communications services. With their services, software engineers can build applications that can make and receive calls and send and receive text messages. Their API makes it easy for software engineers to automate and schedule text messages to remind users on their platform of upcoming events etc.
The next thing is for us to install Twilio using the command “pip install Twilio”. If the installation works, you will get the output below:

Go to www.twilio.com to create a free Twilio account, get your SID and Auth_token, and then click on get a trial phone number, as shown on the screen below.

Add the Twilio account SID and Auth token from your Twilio dashboard to the settings.py of your project.

settings.py

For this project, I want to authorize only the admin to send SMS to customers on the platform, so I will be creating the function that will enable us to send SMS in the admin.py instead of the views.py. In the Django admin panel, we will select which customers we want and then choose "Send text campaign" from the dropdown menu. To send a text message, we instantiate a client object with our account ID and authorization token. Then, for each customer selected in the admin, we create a message by specifying the "to" phone number, using our trial number as the "from" number, and finally inserting our message as the body.

smsapp/admin.py

Next, we rerun our server with the command python manage.py run server. Then go to localhost:8000/admin and login into the admin dashboard. Send the customer’s name you want to send SMS to, from the action dropdown, select send text campaign then click go. Wao! you just sent SMS to your customer on your platform. You can use the add customer button to add more customers and their phone numbers, and send them messages at a go. Note that, the phone numbers must be registered on Twilio if you are using a trial account. If you want to send unverified phone numbers, you will need to upgrade your Twilio account.

CONCLUSION

In this article, we built a Bulk SMS application with Django (Python framework) integrated in Fauna. Fauna serves as the storage point for customer’s information. Then we implemented the SMS API with Twilio to generate SMS to our customers.
If you have any questions, don't hesitate to contact me on my socials:

My LinkedIn handle My twitter handle

USING “ELLIPSIS” IN YOUR CODE.

aidelojep — Fri, 18 Jun 2021 21:11:48 +0000

Hey! I'm Peter. I love to write tutorials and articles to help on some topics I find interesting in Java. If you have any questions about the article, leave a comment and I'll get back to you, or find me on twitter, LinkedIn or Github:
TWITTER LINKEDIN GITHUB

In this article, we are going to discuss a feature in Java or more generally programming, the term ellipsis is denoted as (. . .), it is originally a mathematics concept that is used to denote “....and so on.”
So basically, when applying this concept to programming, it is used to instruct a method to receive an unspecified number of arguments. In this article, our example focuses on arrays. Therefore, to use the concept of ellipsis(. . .) in array, all we need to do is:
specify the data type (int, double, string, boolean...),
then, we declare our ellipsis (. . .) next in the method’s parameter.
This indicates that the method receives an infinite number of variables with that particular data type.
This approach makes our program more concise and precise.

Ellipsis expression:

public class Varargs {

//calculating addition

   public  static void addition (int . . .**numbers**)
        {
 int **total** = 0;

    //calculating total using enhanced for loop 

   for (int p : numbers)

total += p;
return total/numbers.length;
}
public static void main(String [] args) {
int p1 = 10;
int p2 = 20;
int p3 = 30;

//printing formatted data- ( initial values of p)

System.out.printf(“ p1 =%d%np2 =%d%np3 =%d%n);

//printing the sum p

System.out.printf(“The addition of these values(p1, p2 and p3) are:” addition(p1,p2,p3) );
}
}

NB:
// (double slash) indicates comments, comments in programming helps to explain the codes that we write so that they more readable.
For the purpose of this article, we would make use of commenting but most seasoned developers argue that a well written code does not require any commenting except it is not clean enough.
Commenting are not compiled with the source code, they only function to explain our code better.

CONCLUSION

This article helped to explain what an ellipsis does in a (Java) methods. Thanks for reading this article. I hope you like this article feel free to like, comment or share this article with your friends.

😄 Happy Coding…..Wireless API cares…

ARRAYS- Let’s put some human touch to (this.concept).

aidelojep — Mon, 14 Jun 2021 23:55:05 +0000

ARRAYS- Let’s put some human touch to (this.concept).

SERIES 1: BRIEF INTRODUCTION TO ARRAY CONCEPT.

Earlier on, whenever the term “Array” popped up, I used to think to myself, there goes another buzz word, Programming terminology. I struggled to relate this concept to real life scenarios because it felt totally strange and a bit abstract.
Later on, after some level of study and familiarization with the concept of Array, I became more aware of the subconscious application of array concepts in our daily lives. This reality made me look out for ways on how I could apply this new found knowledge to daily life. Simply put, arrays are just variables containing values of similar datatypes.

Variables can be referred to as a container for holding objects or values. So, since we agreed on referring to Arrays as containers, it is safe to assume that these containers can be used as a storage unit for stuffs.
Imagine using our refrigerator to store cool soft drinks of different varieties.
I’m sure a cold drink in a hot weather(tropical) region in Sub-saharan Africa would always be a delight.
Now back to our refrigerator, these drinks contain Coca-cola drinks, guinness drink, milk shakes and vodka at some different position or location in the refrigerator. The position or spot where each drink is located is what we refer to as “INDEX”. It helps us to determine where a particular array value lies in a wide variety of sets. Ofcourse, it becomes easier for me to locate a bottle of coca cola based on where it is positioned in the refrigerator set. Wow! Aren't Arrays just beautiful??!

Also, we must note that in numbering the index of an array, we must start our counting from zero. This is borrowed from a well established mathematics concept of counting. The concept of the number index counting system can be related to Ricci calculus.

In programming, arrays can be symbolized with a set of open/close square brackets [ ]. This is because it serves as a container to hold items. Since, we already established that arrays are a set of variables for holding similar values, therefore, it makes total sense for these containers to hold these values. If you have something of value given to you, you would want to protect it and hold it tight from breaking or falling off. This is exactly what an array does with the values you give to them, they keep them safe and provide them to you whenever you want them to be rendered back.
Also, one very important aspect of arrays that we should also consider is that: “Arrays hold values of similar data types”.
A “data type” refers to the descriptive nature of how the values in a containers behave, it tells us more about their state-it answers questions like: Could these values you trying to store up in the arrays be numbers (integers) , alphabets (strings), or single letter/number/symbols (characters), true or false statements (boolean).
Data types help variable or container objects to create a safe haven i.e a welcoming ground that will be suitable for the arrival of the value that you intend to keep inside of them. For instance, you do not expect to keep toiletries in the kitchen or your shoes in your parlour. A housing apartment is designed in such a manner , such that every item has it’s designated position. This would help to reduce the level of confusion and make things easier to coordinate.

ARRAY LENGTH:
Arrays determine their length based on the number of items it contains. But the little trick to this is, an array length is different from number of items in an array. The array length is usually calculated by saying: Array length minus one. Remember we already established that an array numbers begins from zero, therefore the last item in an array would always be lessed than its length. This concept also helps us to avoid an error known as “ArrayIndexOutOfBound”. We would consider this concept later.

The array length can be calculated by:
arrayName.length which returns the array length.

PS: ‘for loop’ uses array.length to determine the length of the array.

ARRAY INDEX:
The index of an array simply refers to the “position number” of the elements in the array(counting from zero).
ARRAY DEFINITION:
Arrays are groups of variables (called elements/components) containing values that all have the same data types. ARRAYS are OBJECTS, so they are considered “reference types”. To refer to Array elements/values , we make reference to their index.
ZEROth ELEMENT:
This refers to the first element of an array. Please note that an array index must not be negative i.e (non-negative integer).
Please note that all array indexes must be an integer value. It is usually denoted with “int”.

DECLARING AN ARRAY:
Array objects occupy space. Arrays are created using the keyword “new”.
Therefore, to create an array object, you have to:
i) specify the type of array elements (data type).
ii) specify the number of array elements (array length).
The array creation expression below explains better:

int array firstName [ ] = new int [10 ];

where int = refers to the datatype
firstName= refers to the arrayName
new= is the keyword used to create new array
[10]= refers to the length of the array.

ARRAY VALUE:
Array values are denoted using array[counter] assuming counter is what is used in your array creation expression.
ARRAY INITIALIZER:
You can decide to create or declare an array through various ways. You can create an array and initialize it’s elements with ‘array initializer’- a comma separated list of expressions (called an initializer list) enclosed in curly braces {}.

NB: In this case, the array length will be determined by the number of elements in the initializer. E.g

int [] = {2,4,6,8,10,12,14};
The above expression is a 6-element array with index (0-5).

CONCLUSION
We have finally come to the end of our “Introduction to arrays” (series 1).
So, there you go! You should be proud of the progress you’ve made so far on array. We were able to cover areas like:
What is an array?
Array length.
Array initializer.
Array declaration.
How to create/declare an array.
Trust me, you’ve been absolutely amazing! Next episode of the array series, we would look at other aspects of an array and array list like

For now, cheers and goodluck!
This article on array is going to be in three series, namely:

Arrays series 1. (INTRODUCTION).

Array series 2.(INTERMEDIATE).

Arrays series 3. (ADVANCED).

Watch out for this space for more engaging contents on array.

How To Build An Educational Recommendation Application With Python and Fauna

aidelojep — Tue, 13 Apr 2021 06:26:32 +0000

#Python #fauna #serverless

Authored in connection with the Write With Fauna program

In this article, we will explain the steps required to build an educational app (that recommends best learning materials to it’s users based on an algorithm that functions from the user’s history pattern). In building this application, Fauna serverless database, Python and Recommendation Model were utilized.

The educational app aims to assist users by suggesting choicest materials to aid their study. This article further explains how the user’s pattern is used to suggest better ways to source for these materials using a recommendation model.

+Some of the broad areas related to this work include the following:

Fauna serverless Platform.
Python platform.
Machine Learning/Artificial Learning.

GETTING STARTED WITH FAUNA

STEP 1: FAUNA SETUP

Here, the first thing to do is to create the database for our educational app in the Fauna dashboard. If you are new to Fauna and yet to create an account, you will be required to do so via the link attached here:
Fauna Acct Sign Up
In the Fauna dashboard, click on the “NEW DATABASE” button, provide a database name and click on the save button.

STEP 2: GENERATE FAUNA APPLICATION PROGRAMMING INTERFACE (API) KEYS

In order to connect the database to our educational app, we need to generate a Fauna API. We do this by navigating to security settings on the Fauna sidebar (located at the top left-side of the screen).

Once this has been done, you are presented with your API keys ( best to be kept a secret and copied in a place that is easy to retrieve).

STEP 3: INTEGRATE FAUNA INTO PYTHON

At this stage, we proceed to get the Python Library for Fauna. This is available on the pip and can be installed with a single line on the terminal.

After installation is completed, we run the sample code provided in Fauna Python driver docs:
https://docs.fauna.com/fauna/current/drivers/python.html

The above code provides further explanation on how the Fauna Python driver connects to a database with its API key and prints all its indexes.

Now, let us consider the steps to follow to build our educational recommendation application from the Front-End.

BUILDING OUR EDUCATIONAL RECOMMENDATION APPLICATION FRONT-END

Brief Introduction to Machine Learning and Artificial Intelligence:

The term Machine Learning and Artificial Intelligence are used interchangeably very often. But in practice and theory, they do not mean the same thing.

Machine Learning involves application of Artificial Intelligence to systems and thereby providing the ability for these systems to automatically learn and improve from experience without being programmed manually. It involves the ability for computers to be able to develop and explore data, then utilize these data sets for themselves by identifying patterns with very minimal human intervention.

++Machine Learning(ML) can be grouped into three(3) broad categories:

Reinforcement Learning.
Supervised Learning.
Unsupervised Learning.

Artificial Intelligence (AI) is an umbrella terminology that refers to any machine that performs a smart task. AI is a technology that enables machines to simulate human behaviour. In other words, we can refer to all Machine Learning as Artificial Intelligence but not all Artificial Intelligence are Machine Learning.

Artificial Intelligence can also be grouped into four(4) types:

Self Awareness
Reactive Machines.
Limited Memories.
Theory of Mind.

The goal of AI is to produce software that can reason on input and explain on output. Although, AI produces software that will provide human-like interaction and offer relevant supportive decisions but not to be a replacement to humans, not anytime soon.

Some of the mostly used machine learning application includes:

Medical Sector
Banking and stock markets
Speech and image recognition
Regression
Prediction
Product recommendation
Online fraud detection
Social media services.

Facial recognition and detection is an AI example that we use every day without realizing it. This technology works just like humans recognize the face and voice of other people.

This machine learning process lets the AI learn the facial coordinates of a human face and save it in their program for detection. Government and security sectors use this technology for restricted areas to deter unwanted personnel from entering the premises.

Now that we have successfully integrated our Python script to Fauna, let us list the steps to follow to create our Educational recommendation Application.

The Educational Recommendation Model

Getting alternatives or close substitutes for some certain educational material is an issue to a certain individual. This difficulty becomes more real when it involves a third party doing the purchase. Most parents who buy educational materials for their children solely rely on other people’s recommendation. But making such purchases online can be further enhanced using a Recommendation Model which is a machine learning algorithm that can be used to recommend educational movies, educational videos on youtube and reliable sources to access these materials.

Basically, there are three basics of recommendation model which are:

Simple recommender.
Content-based recommender.
Collaborative filtering engines.

In this article, I will be using the content-based recommendation model which suggests similar items based on a particular item. This system uses item metadata, such as genre, movie description, lead acts to make these recommendations. The general idea behind these recommender systems is that if a person likes a particular item, he or she will also like an item that is similar to it. And to recommend that, it will make use of the user's past item metadata.

In building this algorithm (model), I am going to use the Python programming language because of its robust libraries and the fact that it is faster and more accurate and precise when it comes to scientific calculations. For building, this classification model is going to use the Cosine Similarity matrix which takes the distance between points let say point X1, X2, X3, X4...........Xn and check if the distance between two certain points is close if there are close, it will group them together as related (positive) but if there are far apart (negative) then it will group them as dissimilar or unrelated.

I am going to be building these models with a movie data-set which I got from UCI which is a machine learning repository for the data source.

Let’s go through the process of building the recommendation model in python, using some specific libraries.

In building this model the first thing you have to do is to build your environment using this command Python -m venv venv, after that you install the following packages using pip install for windows user while for Linux user you use pip3 install:

A. Sklearn

B. Numpy

C. Pandas

D. Matplotlib

E. Jupyter notebook/Jupyter lab

The sklearn is used for scientific calculation, pandas are used for loading the data into the notebook in other for me to be able to work with, Matplotlib is used for plotting of graphs, Numpy is being used for mathematical computation while Jupyter notebook/jupyter lab is an environment where the python code will be written.

About Data-set

The dataset files contain metadata for all 45,000 movies listed in the Full MovieLens Dataset. The dataset consists of movies released on or before July 2017. This dataset captures feature points like overview, plot, budget, revenue, posters, release dates, languages, production companies, countries, TMDB vote counts, and vote averages.

These feature points could be potentially used to train machine learning models for content and collaborative filtering.

This dataset consists of the following files:

movies_metadata.csv: This file contains information on approximately 45,000 movies featured in the Full MovieLens dataset. Features include posters, backdrops, budget, genre, revenue, overview, release dates, languages, production countries, and companies. And this will be the dataset I will be using for building the recommendation model.

The Full MovieLens Dataset comprises 26 million ratings and 750,000 tag applications, from 270,000 users on all the 45,000 movies in this dataset. It can be accessed from GroupLens website.

                        **Snippet of libraries**

Fig 1.0: Importing Libraries

To load the dataset, I will be using the pandas DataFrame library. The panda’s library is mainly used for data manipulation and analysis. It represents your data in a row-column format. Pandas library is backed by the NumPy array for the implementation of pandas data objects. pandas offer off-the-shelf data structures and operations for manipulating numerical tables, time series, imagery, and natural language processing datasets. Basically, pandas are useful for those datasets which can be easily represented in a tabular fashion.

            **Loading Dataset**

Fig 1.1 Loading dataset

Next, I check for missing values in my data-set in other to avoid bias in our models. From the code snippet below there are missing values in our dataset. In other to avoid the models not be bias we deal with the missing values by replacing them with the mean and mode of the column.

Fig 1.2: Checking for missing values

Fig 1.3: Fixing missing values the mean and mode

Plot Description Based Recommender

In this section, I will be building a system that recommends movies that are similar to a particular movie. To achieve this, I will compute pairwise cosine similarity scores for all movies based on their plot descriptions and recommend movies based on that similarity score threshold.

The plot description is available as the overview feature in my movie dataset. Let's inspect the plots of a few movies:

Fig 1.4: Overview

We have to deal with Natural Language Processing problem. And it is not possible to compute the similarity between any two overviews in their raw forms.** To do this I have to compute the word to vectors of each overview or document, as it will be called. **

As the name suggests, word vectors are vectorized representations of words in a document. The vectors carry a semantic meaning with them. For example, man & king will have vector representations close to each other while man & woman would have representation far from each other.

I will be computing Term Frequency-Inverse Document Frequency (TF-IDF) vectors for each document. This will give you a matrix where each column represents a word in the overview vocabulary (all the words that appear in at least one document), and each column represents a movie, as before.

The TF-IDF score is the frequency of a word occurring in a document, down-weighted by the number of documents in which it occurs. This is done to reduce the importance of words that frequently occur in plot overviews and, therefore, their significance in computing the final similarity score.

In this case, am going to use the sci-kit-learn library which has a built-in TF-IDFVectorizer class that produces the TF-IDF matrix. In other to make the algorithm work properly without bias we remove words that are not relevant to the topic example of such words includes like, the, an, on, etc.

                                **A Snippet of TF-IDF Matrix**

Fig 1.5: TF-IDF matrix.

From the above output, you observe that 22645 different vocabularies or words in your dataset have 5157 movies. With the TFI-DF matrix, it can now be easier for me to compute the cosine similarity. which calculates a numeric quantity that denotes the similarity between two movies. Mathematically it can be express as

Since I have used the TF-IDF vectorizer, calculating the dot product between each vector will directly give me the cosine similarity score. Therefore, I will use sklearn’s linear_kernel() instead of cosine_similarities() since it is faster. This as a result would return a matrix of shape 5157x5157, which means each movie overview cosine similarity score with every other movie overview. Hence, each movie will be a 1x5157 column vector where each column will be a similarity score with each movie.

Fig 1.6: Computation of TF-IDF matrix

I am now going to define a function that takes in a movie title as an input and outputs a list of the 10 most similar movies. In order to do this, I need a reverse mapping of movie titles and DataFrame indices. In other words, I need a mechanism to identify the index of a movie in the Movie DataFrame, given its title.

        **A snippet of the Recommendation model**

Fig 1.7: Recommendation model

After getting the function, you then saved it using joblib and generate the requirements using the command pip freeze > requirements.txt. This will help in avoiding some environmental variable issues while deploying the model on any hosting site, also it will make it easier for other machine learning engineers to contribute and improve on the model.

Conclusion

In this article, we built an educational recommendation application with Python and listed some steps to follow to install Fauna serverless database. We saw how easy it is to integrate Fauna into a Python application. We also gave a brief introduction to Machine Learning and Artificial Intelligence.

If you have any questions, don't hesitate to contact me on Twitter: @PAideloje

Peter Aideloje

Authored in connection with the Write With Fauna program

public class JavaIsBae { public static void main (String....args) System.out.println ("Java is Bae!") }

aidelojep — Sun, 14 Feb 2021 21:48:22 +0000