DEV Community: Shorla

Getting Started with Appwrite on Your App: A Simple Step-by-Step Guide

Shorla — Sat, 21 Oct 2023 23:12:48 +0000

Creating modern web and mobile apps frequently means linking to a server that handles things like user log in, data storage, and other important functions. Appwrite is a fantastic tool that makes this process simpler. In this guide, we'll take you through the steps of setting up the Appwrite client on the part of your app that your users interact with.

What is Appwrite?

Appwrite is an open-source backend server designed to streamline and simplify backend development. Appwrite is like a powerful toolkit for the behind-the-scenes part of building websites and apps. It's full of useful tools, like making sure people can log in, storing data, and handling files. Appwrite can work for small personal projects or big professional apps, so it's super flexible!

Why Start Using the Appwrite Client?

To make Appwrite work with your web or mobile app, you have to set up the Appwrite client on your app's part that people see and use. This client connects your app to the Appwrite server in the background, giving you access to things like user accounts, data, and file storage. Here are other benefits of using Appwrite:

Access to Backend Services: The client serves as a gateway to Appwrite's services, allowing your application to interact with the backend seamlessly. This is crucial for functionalities like user authentication, database operations, and file storage.
Authentication: Initializing the client is a prerequisite for user authentication, as it enables your application to establish secure connections with Appwrite's authentication services.
Data Management: Whether you need to store user data, manage documents, or work with files, the client provides the necessary tools to interact with these services.
Security: The client handles secure communication with the Appwrite server, ensuring that data is transmitted and received safely.

Now, let's get into the step-by-step guide for initializing the Appwrite client on the client side of your application.

Step 1: Include the Appwrite SDK

The first step is to include the Appwrite SDK in your project. You can do this in different ways:

Using Script Tags: Include the SDK in your HTML file using script tags. Appwrite provides a hosted version of the SDK, which you can include in your project by adding the following script tag to your HTML file:

<script src="https://cdn.appwrite.io/javascript/latest/appwrite.js"></script>

npm Package: If you're using a package manager like npm, you can install the Appwrite SDK using the following command: npm install appwrite

Step 2: Initialize the Appwrite Client

With the SDK included in your project, you can now initialize the Appwrite client in your application. Here's how you can do it:

// Create a new instance of the Appwrite client
const appwrite = new Appwrite();

// Set the Appwrite endpoint and project ID
appwrite
  .setEndpoint('YOUR_APPWRITE_ENDPOINT')
  .setProject('YOUR_APPWRITE_PROJECT_ID');

Replace 'YOUR_APPWRITE_ENDPOINT' with the URL of your Appwrite backend server.
Replace 'YOUR_APPWRITE_PROJECT_ID' with your Appwrite project ID.

Step 3: Use the Appwrite Client

Once you've initialized the Appwrite client, you can start using it to access the various services offered by Appwrite. For example, you can interact with the authentication service to handle user registration, login, and account management. You can also use the database service to manage and retrieve data from your application's database.

Here's a simple example of creating a new Appwrite account session:

const { createSession } = appwrite.account;

createSession('email', 'your@email.com', 'your_password')
  .then((response) => {
    console.log('Session created:', response);
  })
  .catch((error) => {
    console.error('Error creating session:', error);
  });

Conclusion

In summary, setting up the Appwrite client is a crucial step when adding Appwrite's powerful features to your web or mobile app. It lets you use various services, makes user login easier, and ensures your app talks safely to the server.

For more information on the Appwrite client, check out the official guidesand examples. With the Appwrite client ready to go, you're all set to create awesome, feature-packed apps that use a strong backend server.

How to Dockerize a Java Application

Shorla — Mon, 27 Feb 2023 19:10:30 +0000

Docker makes it easy to build, manage, and deploy containerized applications. Using Docker during a development process helps to deliver a consistent environment across all machines. While working with a team, it is recommended to use Docker for your applications. This helps the dev cycle not to lag.

In this article, we are going to learn how to dockerize a Java application. However, the basic concepts apply to any technology you are using for your application.

Prerequisite

A conceptualized knowledge of Docker
An IDE
A Terminal — Linux or IDE Terminal
A source code

Steps to dockerizing a Java application

Creating a Java application

Let us create a simple “hello world” application in Java. We can do this by opening any IDE of our choice and creating a file named helloWorld.java. Then, we will copy and paste the code below into the file.

public class helloWorld{ public static void main(String[] args) { System.out.println("Hello world!"); } }

On the terminal, we will compile the code by running:

javac HelloWorld.java

Compiling the code creates a new file — “HelloWorld.class”. The “.class” file runs on the JVM to execute the application. To execute the application, we run:

java helloWorld

The terminal should print out the result Hello world!

Dockerizing the application

We will take the application we built and run it in a Docker container. To do that, it is assumed we have Docker installed on our computer. If not, we can do that here.

Once Docker is installed and started, the next step is to build a docker image for our application. We need a Dockerfile to build a docker image. To create the Dockerfile, we start by creating a new file and naming it Dockerfile. This file will include instructions on how to build the image for our application. The order of the command is important as each command will be executed consecutively.

We can copy and paste the following code to our Dockerfile. To learn more about keywords in Dockerfile, visit here.

# use the openjdk as the base image FROM openjdk # create a new app directory RUN mkdir /app # copy the app files from the host machine to the image filesystem ADD java /app # set the directory for executing future files WORKDIR /app # run the command for executing the application CMD java HelloWorld

The “#” is used to write comments in Dockerfile. We can now build the image by running:

docker build -t hello-world:1.0 .

The “-t” option helps to tag the image with a name for easy access. In the code above, the name or tag assigned to the image is “hello-world:1.0”. The “.” at the end of the code is to specify that the Dockerfile is in the current directory.

if the error message below appears after running the code above, put sudo before running each code.

Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock:

Alternatively, we can add user to the Docker group. Instructions on how to do that can be found here.

The next step is to instantiate our image and run our container. This can be done by running:

docker run hello-world:1.0

The result 'Hello world!' should be printed on the terminal.

To see the list of images available, we can run:

docker image

To see the list of Docker containers currently running, we can run:

docker ps

Note: The container we just prompted will not be on the list. This is because it will be terminated after running.

Conclusion

Following the steps listed above, dockerizing a Java application should be clearer. It is advised to try the steps out on other applications to become more familiar with them.

I recommend reading this article for more information on docker.

Docker: An Easy approach to understanding it

Shorla — Sat, 25 Feb 2023 01:05:55 +0000

According to IBM, Docker is an open-source platform that enables developers to build, deploy, run, update and manage containers—standardized, executable components that combine application source code with the operating system (OS) libraries and dependencies required to run that code in any environment.

This might seem like a difficult concept to understand, especially if you are new to Docker or deploying apps. This tutorial is for absolute beginners.

In this tutorial, you will learn about Docker and get it installed on your local machine.

What is Docker?

In simpler words than the one stated above, Docker is a software or open-source platform that allows you to test, build or deploy applications. Docker helps to put applications in containers so they can run on either local or virtual machines or be deployed to the cloud. This process is referred to as containerization.

Docker is designed to benefit developers and Devops.

What is a container?

Containers are boxes that do not depend on any operating system. This means that it is portable, and can run anywhere. They are however dependent on docker images. They allow applications to be packaged together with their dependencies and deployed to the cloud as a single unit.
Each Container is isolated from other containers. it runs its software, binaries and configurations.

What is a Docker Image?

One of the problems faced by programmers is captured in the phrase "but this application worked on my development machine". This very problem is what Docker image solves.

Docker image is a read-only executable file that includes everything needed to run an application. These include the source code, dependencies and other files packaged with the application in question. Docker images are referred to as snapshots of a docker container at a specific point in time, because of their read-only quality.

What is a Dockerfile?

To create a Docker image, you need a Dockerfile. A Dockerfile contains a set of instructions that are used by Docker to create a Docker image.
Dockerfile is text-based and has no extension.

Basic keywords in Dockerfile

Several keywords are used in Dockerfile to create the set of instructions needed to create a Docker image. We will take a look at the main keywords to get started with Docker.

An image is made up of layers, so think of each line of code in the Dockerfile as an instruction to build a layer of the image. In Docker, all keywords are typed in capital letters as you will see below.

The basic keywords are:

FROM: The first instruction of the Dockerfile specifies the base layer which is FROM. The FROM keyword is used to specify the name of the base image. In Docker, there is a public repository for Docker images called DockerHub. You can pull the already existing base image from there. It is advised to pull only official images or images from a trusted source.

The FROM keyword is used with the base image tag beside it. when no version of the tag is specified, it pulls the latest version.

FROM openjdk

RUN: The RUN keyword helps to run specific Linux commands in the docker file. For example, It can be used to create a directory. The directory created by the RUN keywords lives inside the container, not on the host machine.

RUN mkdir directoryname

COPY: The COPY keyword command works the same way as cp in Linux. it is used to copy files from the host machine to the image file system.

The difference between the RUN and COPY keywords is that, RUN works within the container while COPY runs first from the host machine to the container.

COPY /path/on/the/machine /path/to/the/container

WORKDIR: The WORKDIR keyword sets the directory where future commands will be executed.

WORKDIR /path/to/directory

CMD: The CMD keyword specifies the command that will execute when you start a container from the image. You should use the CMD keyword with a command you will normally use to run an application. For example, to run a Java application, we use java main.

CMD java main

Comment: The # sign is used to write comments in Dockerfile.

To build an image after writing the Dockerfile, we run:

docker build

There are other keywords but these are the basics needed to get started with Dockerfile.

Installing Docker

Docker can be installed on a mac, windows or Linux operating system machine.
To install Docker on your local machine, click here to the official Docker documentation. Choose your Operating system and follow the steps.

Conclusion

In this article, you learnt the basics of Docker, Docker image and Containers. If you followed the documentation, you have Docker setup on your machine now.

You are closer to running your first application on Docker.

Technical sophistication(2)-Psuedocode(1)

Shorla — Thu, 17 Nov 2022 18:32:07 +0000

In our journey to technical sophistication, let's talk about one of the most underestimated and under-utilized tool within the tech community-Pseudocode.

What is pseudocode? How does it add to technical sophistication? What are its benefits? This article and the next sets to explain all that. Keep your tea in hand and read.

FreeCodeCamp refers to pseudocode as 'fake code'. Here is the best way to explain what that means:
Computer languauges are written by humans but require syntaxes and rules that must be strictly adhered to for a successful compilation. Humans do not naturally read in computer languages and often make mistakes in following this strict rules. Hence the thought; How can human-techies, write a program that is similar to computer language, flexible and easy to understand? Pseudocode came to save the day. Psuedocode cannot be understood by the computer though.

In very formal terms, Psuedocode is a detailed yet readable description of what a computer program or algorithm must do, expressed in a formally-styled natural languauge rather than in a programming language.

Rules for writing in pseudocode

Capitalize the initial word.
Make one statement per line.
Indentation is very neccessary to show hierarchy.
Keep it simple, short and readable.
write in the naming format not in computer language format.
End multiline structures using END keywords.

Steps to follow when solving a problem in pseudocode

Understand the question: This is the most important part of the process, if the question is understood, half of the problem is solved and you are ready to take up the challenge.
Break the problem down: Smaller tasks help to get the work done. The more smaller tasks you solve, the closer you are to the full solution.
Understand what the function does: The work of a function is to accept data as input, work on it with steps and return output. The more functions you study, the easier it gets.
Indicate what you need to solve the problem.
Document the high-level solution: This is an excellent way to walk it out.
Evaluate and indicate the outcome.
Detail the step for executing the solution.

Congratulations! You are a step closer to being a sophisticated techie.

In the next article, we will get our hands on real life examples and the benefits of Pseudocode with links to practice section. See you there!

Technical sophistication series(1) – Introduction

Shorla — Tue, 06 Sep 2022 15:10:24 +0000

How do Techies become sophisticated? You may wonder. This post isn't about glasses, big sweatshirts or loosely packed hair. Familiarity with hard skills, such as text editors and the Unix command line, isn't also what this post is about. It is more about the skills and attitude needed to be regarded as not just a techie, but a sophisticated one.

These set of skills are referred to as soft skills. They make problem-solving easier and make your work faster, and are not always included in learning paths. You would wonder why such skills aren't taught easily? Well, soft skills and attitude are particularly difficult to teach.

A best way to illustrate a technical sophistication skill is this flowchart from xkcd

In this series, we will discuss as many of these skills as possible. One of which is debugging.

You are on your way to getting sophisticated! See you in the next article!