DEV Community: Josh

Java Main Method

Josh — Sun, 14 Nov 2021 19:34:18 +0000

Hello everyone, this week I am going to go over one of the most important concepts in Java, the main method. The main method in itself is pretty easy to understand as it is the part that runs the program but there are components to it most early programmers don’t take the time to learn.

Lets start by taking a look at the syntax of the method:

Public: The method must be public so it is accessible. If the method is marked as private, protected, or default the JVM will not be able to locate it.

Static: The static keyword allows methods to be called without instantiating an object first. We don’t want to be required to create an object to run the main method.

Void: The main method doesn’t return anything so we use void as the return type.

Main(): This is the default signature for the JVM and is used to execute a program.

String args []: This is a string array of command line arguments that are passed to the main method. If this is left out of the parameters the JVM will not be able to locate the main method because it looks for a method with a string array.

What is a command line argument?

$ java myProgram arg1 arg2 arg3

You can then use these arguments from the array in your main method if needed.

public class Example {
    public static void main(String[] args) {
        for(String arg: args){
            System.out.println(arg);
        }
    }
}

The last thing I want to touch on is how the main method applies to a process. The main method is a thread in a process that is automatically created by the JVM. Each time a thread is created, the JVM allocates a stack of memory to it. Since additional threads are created from the main thread each additional is considered a child of the main thread which means it must finish execution last. This is because the thread that created another must perform the various shutdowns to safely stop it. For more information on multi-threading please click the link to see my post on it.

That is all for this week. Please leave a like and comment down below if you found it useful. Follow me for more posts like this each week as I work to improve my programming knowledge with you all. Have a great day and happy coding!

Resources:

https://www.javatpoint.com/java-main-method

https://techvidvan.com/tutorials/java-command-line-arguments/

https://javagoal.com/main-thread-in-java/

Getting Started with Docker 🐋

Josh — Sat, 06 Nov 2021 22:47:12 +0000

Hello everyone! This week I am going to give a brief tutorial on how to get started with Docker. See my last post for a conceptual breakdown of what containers are and when to use them. First thing is to make sure you install docker on your computer. Click the link for instructions for Mac, Windows, and Linux. Once everything is set up, you can run the hello world command to verify everything is working.

docker run hello-world

If everything is good to go we will get started with a prebuilt busybox image. Busybox is an executable software suite that contains many Unix utilities.

docker pull busybox

Next you tell docker to take the image and run it as a container. It will look like nothing is happening but docker is running the container behind the scenes.

docker run busybox

In this case the container started but there were no commands passed to the container for busybox to execute so it exited without doing anything. Lets throw it an echo statement to see what it does.

docker run busybox echo “My name is busybox!”

The next feature we are going to look at is the ps command. This is the tool used to see all of the containers that are currently running. Currently if we were to use it there would be nothing listed because the busybox container exits once it is done. If we add the -a option to it then it will all of the containers that have been ran.

Once you are done with a container you can remove it using the rm command followed by the container ID. Note: the container ID below is an example. You will have to look up yours with the ps command.

docker rm 305297d7a235

Understanding the Docker terminology is important to reading up on the documentation for more complex projects.

Images: These are like the blueprints or a snapshot of the application that is going to be put into the container.
Containers: Containers are built using the corresponding image and works kind of like a virtual machine in concept. See my previous post for a more in depth discussion.
Docker Daemon: This is the background service that runs on the host machine. It manages building, running, and distributing them.
Docker Client: This is the command line tool that allows users to interface with the daemon.
Docker Hub: This is a registry of prebuilt docker images like the busybox one we used. You can pull prebuilt images of ubuntu, postgres, python, and many more.

The last thing I am going to discuss before wrapping up this post are Dockerfiles. Dockerfiles are a text file that is a series of commands that tells the client how to build the container. Depending on how complex your container is this can be simple. Below I will show the structure of a Dockerfile for a basic python flask app.

FROM python:3

# set a directory for the app
WORKDIR /usr/src/app

# copy all the files to the container
COPY . .

# install dependencies
RUN pip install --no-cache-dir -r requirements.txt

EXPOSE 5000

The order of operations for this is that you first want to specify the image you are pulling FROM which in this case is Python. Next you specify the working directory and copy all of the files in it to the container. Once that is done you run pip install in the container to install any needed dependencies. For networking you expose port 5000 so that it can be accessed outside of the container. Lastly you run the CMD command to tell the container which command it should run and the file to run the command on.

From here you run the docker build command on the directory that contains the dockerfile which should be in the root folder of your project. See the example below.

docker build -t yourAppFolder .

Well everyone, this was a guide on how to get started with Docker. There are many more things to learn especially if you want to start working with micro-services and have to orchestrate two or more containers for an application. I invite you to dig deeper and try building your own containers for an application. Let me know in the comments if you enjoyed this guide or like this post so that more people check it out. I hope you all have a great week and happy coding!

Resources:

Containerization with Docker 🐳

Josh — Mon, 01 Nov 2021 13:17:26 +0000

Hello everyone! This week I am going to go over containerization in docker and when it might be best to use it. For those that are familiar with virtual machines, containers have the same concept. Their purpose is to create an isolated environment that can be configured for a specific application. Since virtual machines and containers are similar I think it is important to explain the difference between them for those that aren’t familiar.

Virtual machines were developed first and they are essentially virtual computers that are ran on the same hardware. Each VM has it’s own OS and environment. It uses something called a hypervisor to manage the hardware resources between each VM. Disadvantages of a VM is that they are resource heavy and difficult to migrate between platforms.

Containers are similar to VMs in concept but the big difference is that they don’t include the OS in the container. This allows developers to create an environment for the application without including the resource heavy components of the VM. Unlike VMs, containers are easy to migrate between platforms with the same OS and are lightweight.

Containers do have their downsides though, some of which have to do with sharing the OS. Any security vulnerabilities introduced with one container that effects the OS will therefore affect all of the containers on the same machine. The containers are also initialized to work on a specific OS so if you want to migrate it, the new platform will need to be the same. With the positives and negatives weighed, the developer will need to consider what migration, resource, and security concerns will effect the application. Neither method is inherently better and will depend on the type of project.

I hope you all found this post helpful in understanding the basics of what containerization in docker is. Next week I plan on giving a tutorial for setting up and using docker. Please like and comment to let me know how I am doing and I hope you all have a great rest of your week. Happy coding!

Resources:

AI Applications in Medication-Therapy-Management

Josh — Fri, 29 Oct 2021 18:21:48 +0000

***Hello everyone. This post is a bit different from what I normally write on dev.to. Please visit my Medium blog where I will start posting more long form discussions such as this one if you find it interesting. Thank you!

In today’s world, pharmaceuticals help manage a wider range of health concerns than ever before. Prescription medications are combined with lifestyle changes to create a care plan to improve patient’s health. However, for many people it can be difficult to connect with the right medical professionals to optimize or receive care. There are programs in place, often required by state funded healthcare entities, that have insurers provide services by pharmacists to members to review and manage their medications. The benefits of these programs can be staggering. Patients that take many medications often have difficulty recalling all of their medications or relaying concerns. The goal of a pharmacist here is to establish a complete medication reconciliation and then optimize each component. Some medications are best used at a certain time of day, cause an interaction with vitamins or supplements, or are not acting as effective as hoped by the physician. By regularly meeting with a pharmacist the patient can get a form of care that often is lacking in a fast paced provider appointment.

The benefits of these programs are pretty apparent when fully utilized. It makes you wonder why this is not available to everyone? Unfortunately healthcare is a very specialized role that requires many years of studying and certification. Healthcare professionals are also expensive to employ and it is not cost effective to offer this service to everyone. This is where AI can help. Most of the users that would benefit from these programs don’t realize that they are available to them. Insurers and health providers have a large amount of patient data that can be utilized effectively. AI can be used to identify patients and points of concern. Over time the models can be enhanced to determine who has the greatest need and allow staff to outreach to this population to see if they would be willing to participate.

To breakdown this system we will first look at who would be eligible for the program. The system would need to utilize machine learning techniques to take large amounts of data and create models on who would benefit from the program the most with the restraints of providers available. For those not familiar, machine learning is a subsection of AI programming that uses modeling techniques to train a program to analyze and make decisions through data. The system could take into account pharmacists who have specializations in fields such as Hepatitis C or Oncology and allocate them for those patients. The models would need to include factors such as comorbidity, medication volume, and total providers currently in their care. Once patients have been identified and scheduled the system can further assist pharmacists by identify talking points that may need addressed. Pre-appointment forms, insurance claim history, and EMRs can provide data on: which providers prescribe specific medication, medication dosing/strength, unaddressed health concerns, etc. Machine learning techniques can tap into drug databases such as Lexicomp to find sub optimal dosing or interactions to discuss in the appointment. Time of day, number of tablets, and cost are inconveniences that can deter patients from being compliant with their medication regimen which may be optimized with Pharmacist intervention.

With any AI application or private health information (PHI) it is important to consider the ethical ramifications of the product and the potential for harm. Starting with the selection process, the AI would be largely in charge of deciding who is to receive services and who will not. Safeguards will need to be in place to try and avoid discrimination. Cultural or systemic limitations may not allow people to submit necessary or accurate information that would trigger an acceptance by the AI. Once patients are in the program there can be additional barriers to understanding and accepting help from a pharmacist. Patients that may speak another language would require an interpreter or provider that can speak the language. Additional cultural components may prevent a patient from accepting care if not presented in a way appropriate for them. Lastly, with any healthcare entity there is always the fear of releasing PHI or violating HIPAA. Measures will need to be taken to ensure that access to PHI is limited only authorized personnel that have a need for it in order to provide services.

As you can see, AI in healthcare has a huge potential to automating processes that can increase access to care. Increasing efficiency can relieve some of the burden that is plaguing the system and decrease overall costs. As with anything there are possible pitfalls that will need to be identified and addressed but this is to be expected with any new system. The possibilities here are exciting and can usher in a new paradigm of healthcare for future generations.

How do Websites Work?

Josh — Tue, 26 Oct 2021 01:16:15 +0000

Last week I went over the basics of the hardware and protocols that allow the internet to function. In this second part of the series I am going to deep dive into the steps that go into displaying a website so that we can better understand the protocols in place. The steps are:

DNS Query
TCP Handshake
TLS Handshake
HTTP Request
HTTP Response

A DNS query is your computers way of taking a domain name and finding the correct IP address of the site you are trying to visit. A request is sent to a DNS resolver chosen by the user which then queries the IP address from its DNS servers and returns it to the client that sent the request. The default DNS resolver is usually your internet service provider. The URL is broken up into different servers such as a Top Level Domain (TLD) server which would contain directories for each .com extension. This example is known as a recursive DNS query whereas a non-recursive query follows the same procedure but the DNS client (user’s computer) will take on the responsibilities of the resolver and directly ask the servers itself.

A TCP handshake is a way of establishing a connection with the host destination. It is a three-way handshake used to synchronize and acknowledge the packet transmission before the process starts. The client initiates the transfer by sending a a Synchronize message used to establish a connection and advise of the sequence numbers used to keep track of the packets being sent over. The host server then responds back with an acknowledge message. The last message is another acknowledge message sent back to the server and then the connection is established. After the connection is completed a FIN message is sent to the server to disconnect the session.

The next step in the process is the TLS handshake. TLS is an encryption protocol for internet communication. It is the evolution of the previous protocol used, SSL. The steps of the handshake are to first specify which version of TLS will be used. Next is to establish the cipher suites utilized. Third, authentication of the server through the server’s public key and the SSL certificate authority’s digital signature. Lastly, generate session keys to use symmetric encryption for the duration of the connection. This is a generalized version of the exchange which is broken up into more steps and is dependent on the key exchange algorithm and cipher suites supported. See this link for more information.

The last two steps to view a web page are HTTP requests and responses. HTTP is a protocol used to request and receive information from a web server. A request is sent with a method it wishes the server to perform and relevant information needed in order to execute that action. Common request methods are GET, POST, and UPDATE. A GET method asks the server for the information at the provided URL in the header. Your browser will send a GET method in order to get the HTML and CSS for a website to render. Once the request is received by the server it will send a response back as a status code. Status code 200 means the request is OK and the server starts sending over packets of data. Click here for a list of request methods and here for status codes.

What I have provided is a high overview of how an internet web page is rendered. Each section has a lot more you can spend time researching if you choose to do so. Below I have provided links to the resources I used to write the post. I hope you learned something and if you did please feel free to like the post or leave a comment below. Have a great week and happy programming!

Resources:

- DNS Query:

- TCP Handshake

https://www.guru99.com/tcp-3-way-handshake.html

- TLS Handshake

https://www.cloudflare.com/learning/ssl/what-happens-in-a-tls-handshake/

- HTTP Request/Response:

How does the Internet Work?

Josh — Sun, 17 Oct 2021 22:51:14 +0000

One thing that many of us take for granted is the internet. The internet is this vast distributed network that connects all of us in almost everything we do. Probably like you, I had no idea how it worked, even at a high level overview. Today I am going to go over the basics of how a system this vast and independent operates.

First, what is a network? A network is a group of computers that are connected to each other. They can share information by passing parts of the whole called packets. Sometimes the devices sharing packets of information with each other are different. This required standardization that could be implemented into each device called protocols. A protocol is a set way of performing certain actions or organizing the data. Protocols exist for sending data between computers on a local network (IP), making sure they arrive in the right order (TCP), and to format them for websites and web applications (HTTP).

Next I will describe some of the physical components that contribute to the internet:

Routers: These forward packets to different networks based on their destination. One way to think of them is if each time you passed through an intersection in your car there was a person there to tell you which direction to go in order to get home.
Switches: These are similar to routers but they work on a local network. They take information passed from one source and send it to the computer it was meant to go to.
Web Servers: These are high-powered computers that take requests and serve information. They may need to process requests and apply business logic before responding with the appropriate data which can be computationally intensive.

Now that we have some of the basics understood lets look at the specific steps that go into displaying a website on your computer.

DNS query: Computers use IP addresses to find where a website is located on the network. IP addresses are long and hard to remember so we use DNS to apply an easier naming convention. Think of it as a phone book for IP addresses. So a DNS query is essentially looking up an IP address with the URL provided.
TCP handshake: This is the process of opening up a connection to the IP address with your browser.
TLS handshake: The browser encrypts the connection to try and prevent malicious individuals from being able to read the packets if they are intercepted.
HTTP request: The browser uses the HTTP protocol to “ask” for information from the web server.
HTTP response: The web server processes the request and provides a response for the browser to render on your computer. For applications other than a browser it may just provide data.

These are the basics for how the internet and local networks function. I plan on going deeper in the future about DNS, TCP, TLS and maybe more. Let me know in the comments if you would find that helpful or if you enjoyed this post. I hope you all have a great week and happy coding!

Resources:

https://www.cloudflare.com/learning/network-layer/how-does-the-internet-work/

https://www.hp.com/us-en/shop/tech-takes/how-does-the-internet-work

https://developer.mozilla.org/en-US/docs/Learn/Common_questions/How_does_the_Internet_work

Lambda Expressions in Java

Josh — Mon, 11 Oct 2021 02:00:16 +0000

This week we are going to go over something I have ran across but didn’t really understand until recently, lambda expressions! Lambda expressions are Java dipping its toes into functional programming. It takes parameters and applies it to an expression or code block. Below is a basic example of the syntax:

(parameter1, parameter2) => expression

(parameter1, parameter2) => {code block}

Lambda expressions are extremely limited and must immediately return a value if it isn’t void. They can’t use keywords such as if or for to maintain simplicity. If more lines of code are needed then you can use a code block instead.

Now when implementing lambdas you can’t only use the expression. Lambdas are implementations of functional interfaces. A functional interface is an interface that only has one abstract method. The benefits of lambdas are that they allow you to implement the method without having to implement the interface’s class and instantiate an object. An example of this is below:

interface FuncInterface
{
    // An abstract function
    void abstractFun(int x);

    // A non-abstract (or default) function
    default void normalFun()
    {
       System.out.println("Hello");
    }
}

class Test
{
    public static void main(String args[])
    {
        // lambda expression to implement above
        // functional interface. This interface
        // by default implements abstractFun()
        FuncInterface fobj = (int x)->System.out.println(2*x);

        // This calls above lambda expression and prints 10.
        fobj.abstractFun(5);
    }
}

Lambda expressions are often used as parameters to a function. To increase readability you can also store lambda expressions in a variable as long as the type is an interface that only has one method, the same number of parameters, and the same return type.

import java.util.ArrayList;
import java.util.function.Consumer;

public class Main {
  public static void main(String[] args) {
    ArrayList<Integer> numbers = new ArrayList<Integer>();
    numbers.add(5);
    numbers.add(9);
    numbers.add(8);
    numbers.add(1);
    Consumer<Integer> method = (n) -> { System.out.println(n); };
    numbers.forEach( method );
  }
}

A common use for lambdas are creating threads. Here is an example of implementing a Runnable object with a lambda code block for the thread to execute.

// Lambda Runnable
Runnable task2 = () -> { System.out.println("Task #2 is running"); };

// start the thread
new Thread(task2).start();

Most of us as beginners have been taught to program using OOP concepts so it can be a bit jarring to use a different paradigm like functional programming. I myself am still learning to wrap my head around these concepts. Anyway, I hope you all were able to learn something today. If you have more questions or want to deep dive into this topic check out the links below that I used to write this post. The code examples I pulled are also from there. Have a great week!

Resources:

Implementing Threading with Java

Josh — Sun, 03 Oct 2021 22:12:23 +0000

In my last post we went over what a thread is and how it fits in the scope of a process. Now we are going to discuss two ways of implementing them in Java which are,

Extending the Thread Class
Implementing the Runnable Interface

Starting with working in the Thread class, see the code block below taken from w3schools.

public class Main extends Thread {
    public void run() {
        System.out.println("This code is running in a thread");
    }
}

This method works by extending the Thread class and overriding its run () method. Another example is provided below for threading with classes.

public class Main extends Thread {
    public static void main(String[] args) {
        Main thread = new Main();
        thread.start();
        System.out.println("This code is outside of the thread");
    }
    public void run() {
        System.out.println("This code is running in a thread");
    }
}

Next we have an example of implementing the Runnable interface.

public class Main implements Runnable {
    public void run() {
        System.out.println("This code is running in a thread");
    }
}

As before another more complex example using classes is provided below.

public class Main implements Runnable {
    public static void main(String[] args) {
        Main obj = new Main();
        Thread thread = new Thread(obj);
        thread.start();
        System.out.println("This code is outside of the thread");
    }
    public void run() {
        System.out.println("This code is running in a thread");
    }
}

Now at this point you are probably wondering why there are two ways of implementing threading in Java. If you remember from early in your programming journey, you can only extend from one class in Java. If you extend from the Thread class that means you miss out on inheritance benefits from other classes. However, the Thread class does have some pre-built useful methods that can streamline some of your code. These are things you will need to consider when choosing how to implement threading into your project.

Runnable and Thread both use the run method. This method is where you code the functionality of the thread. When you want the thread to start executing you then call the start method for the object.

Now that we are up to speed on how to create a thread the next thing to consider is concurrency. The main benefit to threading is that they perform lightweight operations at the same time. However this can be a bad thing too. The programmer never knows the order of execution for the threads in the process. If an application was set up for multiple threads to perform actions on a variable for instance, it is impossible to know the order of operations performed on the variable. As a general rule it is best to configure threads to share as little attributes as possible. In the real world this can not always be achieved though, so there are ways of solving for concurrency and performing thread safe actions.

An example is the use of the isAlive() function in the Thread class.

public class Main extends Thread {
    public static int amount = 0;

    public static void main(String[] args) {
        Main thread = new Main();
        thread.start();
        // Wait for the thread to finish
        while(thread.isAlive()) {
            System.out.println("Waiting...");
        }
        // Update amount and print its value
        System.out.println("Main: " + amount);
        amount++;
        System.out.println("Main: " + amount);
    }
    public void run() {
        amount++;
    }
}

As you can see from this weeks post that threading in itself is not too complicated to implement but as you add threads and run into concurrency problems it can get to be a huge undertaking to keep track of. Thank you everyone for reading my post this week. Please make sure to visit the links down below for more detail and examples on how to use threading in a project. I also want to thank w3schools.com for their implementation examples that I used in the post. Please feel free to leave a like and comment if you found this helpful.

Resources:

Understanding Threading

Josh — Sun, 26 Sep 2021 22:09:22 +0000

Multi-threading is a feature used to process concurrent requests in order to maximize efficiency. Executing one piece of code at a time may work for lightweight programs but can really bog down the system if something heavy needs to be done. One way to think of it is if you are driving a car up a hill that only has one lane. If the road is only passenger cars driving a normal speed then it probably would not be an issue. However if a semi-truck was ahead of you it would take forever to get over the hill. Threading has similar concepts to creating two lanes on the road. With two lanes the cars can drive at different speeds next to each other and the semi-truck isn't slowing the flow of traffic.

In reality threads are a bit more complicated. A thread is an execution context, which is information the CPU needs to execute and keep track of a list of instructions. The execution context holds register locations where the next line of instructions is waiting it’s turn. CPU’s give the illusion that they are doing multiple computations at the same time but it is starting and stopping many things very quickly.

Zooming out a bit, you can see in the image above that threads are part of a process. A process is an instance of the program being executed. The threads make up the Process State of the process and contain the information needed to keep track of what still needs to be computed in the program. The process also contains other resources such as the code, data, heap and stack. Some of these resources are shared while others can be thread specific.

Now like everything in programming, if this is such a great boost to efficiency why don’t we apply it to everything? Threads do impose minimal impact, require less overhead to create/maintain/manage, and can provide structure simplification. However, they are much more complicated to implement. They also bring about problems with concurrency. The programmer doesn’t know which order of operations the threads are going to execute so safeguards have to be implemented to guarantee the validity of data. Without protection, one thread may manipulate data that will ruin it for computations by other threads.

Now that we have an understanding of what threading is, next week we will discuss how to implement it in Java! I hope you all have a great week and feel free to leave a comment and a like on the post.

Resources:

Lazy Initialization

Josh — Sun, 19 Sep 2021 22:29:12 +0000

While searching on Stack Overflow for solutions to problems, I notice certain terms and phrases that are mentioned frequently. One of the most common I see is lazy initialization. Why would we want anything to be lazy? Lazy initialization in a nutshell is the idea of delaying initialization of an object until later when it is needed. When an application creates many objects, taxing operations performed by each object can add up. If you don’t need those operations right away then why would you perform them immediately and bog down the system?

public class LazyInit {

    private static Resource resource;

    public static Resource getResource() {
        if (resource == null) {
            resource = new Resource();
        }
        return resource;
    }
}

Using a code snippet taken from an article published by Maciej Najbar, you can see an example for a single thread implementation. For those that have used the Singleton design pattern this may look familiar. The class creates a placeholder for the Resource object name resource. Using the getResource() method the object is checked to see if it has been initialized with a value or is null. If null, it is then assigned with a value which is returned otherwise it just returns the value already assigned. This allows the programmer to create conditions on when the initialization occurs with the getResource() method rather than in the constructor at object creation.

Examples on when it may pay to be lazy

Loading images in a web application
Java Spring Boot Beans
Database connections
Blog posts

As with everything there are some downsides to consider. Lazy loading is more taxing on the system than just initializing the object. This is why everything isn’t implemented that way. Some systems may need these objects to be created right away to be configured correctly. Also, it may be harder to debug since errors or exceptions won’t be thrown until initialization. As with anything in programming there are both pros and cons to consider before implementing. Make sure to weigh the costs on the system before adding a lazy loading to your application.

Resources:

Najbar, M. (2019, January 23). Lazy initialisation - what's a correct implementation? Medium. Retrieved September 19, 2021, from https://medium.com/android-news/lazy-initialisation-whats-a-correct-implementation-64c4638561e.
Maayan, G. D. (2020, December 25). Don't be LAZY: 3 problems with lazy loading and when to use eager loading. Hacker Noon. Retrieved September 19, 2021, from https://hackernoon.com/dont-be-lazy-3-problems-with-lazy-loading-and-when-to-use-eager-loading-qq1d34cl.

What is OAuth?

Josh — Sun, 12 Sep 2021 22:29:05 +0000

Most websites that users visit today have some sort of user authentication to access their services. Previously website providers would implement HTTP Basic Authentication where the user would be asked for a username and password through a form on the web page. The site would then use that information to log in as you. The client would receive an authenticated API key ID and a secret to then send to the server with each HTTP request.

What’s wrong with this?

Giving log in credentials to a third-party application or site can greatly compromise security. Once the credentials have been acquired they cannot be revoked. Also, there is no way to control how much user access these applications have in the system.

Enter OAuth. The idea behind OAuth is that you grant the application authorization to data while keeping authentication secure. This limits access to only information that is required which can be revoked at any time.

OAuth works through a series of steps. First the third party application requests a token with a secret from the provider. Once granted, the third party application has the user login to the provider with the token to grant the levels of access required. Once approved, the provider marks the token on their end and it can be used to access the API within the allowable scope. See the info-graphic below for a visual representation of this.

Implementation of this depends on the framework being used. I primarily use Java so I would choose the Spring security module within Spring Boot. For more information and a tutorial please see the link listed in resources.

That is all I have for my post this week. I hope you learned what OAuth is and how it works within an application. Feel free to like and comment the post below as I will greatly appreciate it.

Resources:

Spring Boot OAuth Tutorial:
https://spring.io/guides/tutorials/spring-boot-oauth2/

Sobers, R. (2018, August 30). What is OAuth? Definition and how it works. Inside Out Security. Retrieved September 12, 2021, from https://www.varonis.com/blog/what-is-oauth/.
Raible, M. (2017, June 21). What the heck IS OAuth? Okta Developer. Retrieved September 12, 2021, from https://developer.okta.com/blog/2017/06/21/what-the-heck-is-oauth.
Paul, R. (2010, January 18). OAuth and OAUTH Wrap: Defeating the password anti-pattern. Ars Technica. Retrieved September 12, 2021, from https://arstechnica.com/information-technology/2010/01/oauth-and-oauth-wrap-defeating-the-password-anti-pattern/.

Aggregation Pipeline

Josh — Sun, 29 Aug 2021 04:35:55 +0000

Welcome back everyone. For this post I am going to continue talking about databases, specifically the aggregation pipeline in MongoDB. Most people learn how to pull data by using find commands in the Mongo Shell. While this is fine for simple queries it becomes insufficient as requests become more complex. This is where the aggregation pipeline comes in. It breaks up the query process into stages that form the pipeline. A generic example can be seen below.

The most common stages are:

Match: Filters the documents to pull what is needed
Group: Separates the documents into specified groups
Sort: Sorts the documents in each group (ex: ascending or descending)

There are other more complex stages such as unwind and project but we will not be going over them.

The syntax to create a pipeline is to first create an array of JSON documents that contain each stage in the order you wish them to be performed. See an example below.

pipeline = [
    {$match : {name: “John”},
    {$group : {_id: “city”},
    {$sort: {age: 1}
]
db.collection.aggregate(pipeline)

Walking through the example, the pipeline first finds all of the documents that have a name that equals John. It then groups all of the John’s by their city and sorts them in each group by their age in ascending order.

As you can see this form of query can be extremely powerful and enhance readability of complex operations. It is important that as you learn to use the framework that the stages are ordered in ways to increase performance and do not hit the memory limitations. Let me know down below if you enjoyed the post and I hope you have a great rest of your week.

Resources:

Couto, J. (2021, May 4). The beginner's guide to MongoDB Aggregation (With Exercise). Studio 3T. https://studio3t.com/knowledge-base/articles/mongodb-aggregation-framework/.
Aggregation pipeline. Aggregation Pipeline - MongoDB Manual. (n.d.). https://docs.mongodb.com/manual/core/aggregation-pipeline/.