Author Archives: proctech21

Items API

The API is the most important aspect of web development. The program’s functionality is divided between the front end and the back end. Our assignment has been based on the front end since this week. Create, delete, list, update, and order items, among other things. To help you comprehend the entire process, I’ve created a rudimentary image that will aid with the demonstration’s layout.

Front-end web development, sometimes referred to as client-side development, is the process of creating HTML, CSS, and JavaScript for a website or Web application so that a user can see and interact with it directly. The difficulty with front end development is that the tools and techniques used to produce the front end of a website change all the time, necessitating the developer’s ongoing awareness of how the field evolves.

In an app, items are entries. Items are the rows in the table if you conceive of the app as a table. Items are made up of some basic information as well as values for each of the app’s fields. There can be many values (for example, several links to another app) and multiple sorts of values for each field (F.ex. a field of type date field consists of both a start date and an optional end date). A string id called a sub id is used to identify the type. The sub id values denote the kind of most fields, which is usually only one. Others have a number of sub ids. For each field, the sub ids and their values are provided below:

The Items API allows you to:

Verb             Path                                    Action                    Description

POST          /api/items                              create                    Create item

GET           /api/items/:id/image            image                   /api/items/:id/image

GET           /api/items                              index                     Query items

GET            /api/items/:id                        show                      Show item

PATCH      /api/items/:id                         update                   Update item

PUT           /api/items/:id                         update                   Update item

It takes a combination of programming, arithmetic, and human interaction to turn a visual design into a fully working  web design.

This will have an impact on you. HTML is loaded into a browser and interacts with other resources such as CSS and JavaScript to create a website. You may not be writing the code, but there are dozens of elements that a developer must consider in order to make this work, and you should be aware of these demands and effects, as well as the fundamental tools of the trade.

Developers have come to identify and specialize with one side of the front-end/back-end duality as both sides have become increasingly complicated. Most web engineers made a career decision about whether they wanted to work on the front-end or the back-end somewhere in the previous ten years, and new developers are making the same decision today: Do they want to work with front-end, presentation-level code, or back-end, processing-level code? It’s up to you to decide.

From the blog CS@Worcester – Site Title by proctech21 and used with permission of the author. All other rights reserved by the author.

API

API stands for application programming interface, which is a set of definitions and protocols for building and integrating application software.

How do APIs work?

The Application Programming Interface (API) is a software interface that allows two apps to communicate with one another without the need for a human to intervene. A programming interface (API) is a set of software capabilities and operations. A software code that can be accessed or executed is referred to as an API. API stands for application programming interface, and it is a code that allows two different software programs to communicate and exchange data with one another.

It allows goods or services to talk with one another without requiring knowledge of how they are deployed.

Consider the following example to better understand how the API works:

Let’s look at how API works with a basic example from everyday life. Assume you’ve gone to a restaurant for lunch or dinner. The server approaches you and hands you a menu card, which you can modify by specifying that you want a veggie sandwich without onion.

The waiter will take your order once some time has passed. However, it is not as straightforward as it appears, since there is a process that occurs in the middle.

Because you will not go to the kitchen to pick up your order or tell the cooking crew what you want, the waiter will play a vital role in this situation.

API also does the same by taking your request, and just like the waiter tells the system what you want and gives a response back to you.

Why would we need an API?

Here are a few reasons to use API:

  • The abbreviation for Application Programming Interface is API. API allows two separate software applications to communicate and exchange data.
  • It makes it easier to incorporate content from any website or application.
  • App components can be accessed using APIs. Services and information are delivered in a more flexible manner.
  • The generated content can be automatically published.
  • It enables a consumer or a business to personalize the material and services they utilize the most.
  • APIs assist in anticipating changes in software that must be made over time.

To sum up, the major reason APIs are so important in today’s marketplaces is because they enable speedier innovation. Change barriers are removed, and more people can contribute to the success of an organization. They have two advantages: they allow the company to generate better products while also distinguishing itself from the competitors.

From the blog CS@Worcester – Site Title by proctech21 and used with permission of the author. All other rights reserved by the author.

Docker

Hello and welcome to “Docker Containers’ Power.” Let’s take a closer look at what Docker containers have to offer in terms of the development process.

What is Docker?

Docker is an open-source project that automates application deployment into portable, self-contained containers that can run in the cloud or on-premises. Docker is also a firm that promotes and develops this technology, collaborating with cloud, Linux, and Windows manufacturers such as Microsoft.

Developers can use Windows, Linux, or macOS development environments. The developer launches a Docker host on the development computer, which deploys Docker images, containing the program and its dependencies. As far as I know, developers that work on Linux or macOS utilize a Linux-based Docker host and can only produce images for Linux containers. Developers using macOS can make changes to their code.

Docker Desktop for Windows or macOS is available to host containers in development environments and gives extra developer tools. These solutions set up a virtual machine (the Docker host) to run the containers. There are two types of runtimes for Windows Containers:

Windows Server Containers use process and namespace isolation technology to enable application isolation. A kernel is shared by a Windows Server Container, the container host, and any containers executing on the host.

By operating each container in a highly efficient virtual machine, Hyper-V Containers improve on the isolation given by Windows Server Containers. The kernel of the container host is not shared with the Hyper-V Containers in this setup, which provides better isolation. The images for these containers are made in the same way and have the same functionality. The difference is in the way the container is built from the image and operating a Hyper-V Container necessitates the use of an additional parameter.

Comparison of traditional virtual machines to Docker containers.

Infrastructure, Host Operating System, and Hypervisor are the three foundation layers of the host server for VMs, and each VM has its own OS and all necessary libraries on top of that. The container engine, which keeps containers isolated while sharing the base OS functions, is installed on top of the infrastructure and OS on the host server for Docker.

Containers are simple to deploy and start since they use considerably fewer resources (for example, they don’t require a full operating system). This allows you to have a higher density, which means you can operate more services on the same hardware unit and save money.

From the blog CS@Worcester – Site Title by proctech21 and used with permission of the author. All other rights reserved by the author.

UML Diagrams

Why do we need to know UML Diagrams?

UML diagrams can be used as a way to visualize a project before it takes place or as documentation for a project afterward. Seeing what you are doing and being able to measure where you are at in your project can help simplify the workloads and decrease the amount of stress that you may have. But the overall goal of UML diagrams is to allow teams to visualize how a project is or will be working.  

We have heard people say this word a lot: a picture is worth a thousand words. That’s why visualizing a process, especially during the development phase, is crucial for team communication and collaboration. The software development industry in the past has used dozens of ways to model and visualize development. 

We probably might ask what is exactly a UML? UML stands for Unified Modeling Language. It is a modeling language that is most often used for software engineering but has extended its use to business processes and other project workflows. Essentially, UML is visualizing software through diagrams. 

 Three software engineers at the company Rational Software for their projects have created this modeling language, and since it has become the standard with very few changes over the years. 

Software engineering and other business processes use UML diagrams to modeling their work which is a big part of today’s world.  

There are two main ways UML diagrams can be used:

  • Forward design. The modeling and design are all done before coding the software application. Usually, forward design is used to help developers better see the system they are trying to create. 
  • Backward design. The modeling is done after the code has been written, and the UML diagrams act as documentation for the workflow of the project. This can help developers see the project development as it was, in reality, to improve in the future.

Whether UML diagrams are used before or after the coding or project, they provide a way to visualize many aspects of a project and who is responsible for what activity.

I found that UML diagrams, help me to improve my coding skills. Being able to look at every aspect of my project design not only makes it easy but, also faster, especially when it comes to Object Oriented Programming. UML diagrams can be used as a way to visualize a project before it takes place or as documentation for a project afterward. 

From the blog CS@Worcester – Site Title by proctech21 and used with permission of the author. All other rights reserved by the author.

Interface

Abstraction is the most essential piece of object-oriented design. It allows the client peace of mind when it comes to the implementation details of functionality. In Java, abstraction is achieved through abstract classes and interfaces. This post will find the idea of the Interface Segregation Principle.

An Interface is a set of abstractions that an implementing class must follow. We define the behavior but don’t implement it:
in the example below, we will find how that is being written.
interface Car {
void break();
}
Using the interface as a template that actually can help us to implement the behavior:
class Toyota implements Car {
public void break(){
// Toyota-specific implementation
}
}
What Is the Interface Segregation Principle?
The Interface Segregation Principle (ISP) states that a client should not be exposed to methods it doesn’t need. Declaring methods in an interface that the client doesn’t need is problematic for several reasons.
Let’s look at an example to understand why the Interface Segregation Principle is helpful.
By creating these codes below you will be able to analyze how the methods are being called. Let’s formed an order service place where a customer can order an oil change, change tires, or basic tuneup:

interface OrderService {
void oilchange(int quantity);
void tirerotation(string front, string back);
void basictuneup(int quantity, string front, string back);
}

Since a customer has the opportunity to order an oil change, or tire rotation, or both, it will make sense to put all order methods in a single interface which be seen in the codes below.

class OilchangeOrderService implements OrderService {
@Override
public void oil-change(int quantity) {
System.out.println(“Received order of “+quantity+” oil change”);
}

@Override
public void ordertireroation(string front, string back) {
throw new UnsupportedOperationException(“No tirerotation in oil change only order”);
}

@Override
public void ordertuneup(int quantity, string tireration) {
throw new UnsupportedOperationException(“No tirerotation in oilchange only order”);
}
}
Similarly, for a tirerotation-only order, we’d also need to throw an exception in orderOilchange() method.
And this is not the only downside of this design. The OilchangeOrderService and TirerotationOrderService classes will also have unwanted side effects whenever we make changes to our abstraction.

This change will also affect oilchangeOrderService even though it’s not implementing this method!
By violating the ISP, we face the following problems in our code:
• Client developers are confused by the methods they don’t need.
• Maintenance becomes harder because of side effects: a change in an interface forces us to change classes that don’t implement the interface.

From the blog CS@Worcester – Site Title by proctech21 and used with permission of the author. All other rights reserved by the author.

Object-Oriented Programming(OOP)

This week’s blog focuses on the aspects of object-oriented programming. Understanding OOP well is essential for any developer who wants to build a high-quality software program.

In object-oriented programming, the program will be divided into many different small, manageable, reusable programs.

Each of them has its own identity, data, logic, and how it’s going to fit with the rest of the others. Usually, we may think about objects, we think about the real-world application. Something we should be able to see, touch, and feel. Then Object-Orientation was intended to be closer to the real world.

As mentioned above something is visible to all of you, like the buildings, Vehicles, Foods. Something that you can’t touch but will be able to feel or not like the time, temperature, events.

Well in programming each object has its attributes, and behavior. Objects are separate from one another as we expect them to behave. They are independent have their history and their own identity.

What are attributes in Objects?

As I said, Objects are independent due to their nature, they have their properties. For example, in the case of a vehicle, its model, color, year, and more. Their roles are to describe the current state of an object because each state is independent of the other. A vehicle might make by Toyota that’s red and another maybe blue.

How do they behave?

Behavior is certain action that the Object can perform. For example, in the case of a vehicle, it will be able to speed, stop, or horn. It’s important to remember that each has independent of the other.  To talk about Objects, Classes become inherently related.

What is a class, and how does it fit into our program?

Well, a class is a place where you can identify the behaviors and properties of an Object. The properties and behavior of an Object will be defined inside a class.

Abstraction, Encapsulation, Inheritance, and Polymorphism play a big part in object-oriented programming. This means that the focus starts on the common properties and behaviors of some Objects and left out the less important things. Separate the program into small pieces. Instead of creating different classes, we can instead create one generic class that has the common, and essential properties and behavior of those classes. use Polymorphism where an object can take the shape of many different forms. This is a very quick statement showing the stage of Object-Oriented Programming

From the blog CS@Worcester – Site Title by proctech21 and used with permission of the author. All other rights reserved by the author.

Introduction

This is my first blog, and I hope this is the beginning of many. I will post all my content here for discussion. We can agree that learning new tools help further your skills and ultimate power to greatness.

From the blog CS@Worcester – Site Title by proctech21 and used with permission of the author. All other rights reserved by the author.