Author Archives:

APIs and REST APIs

Hello everyone and welcome back to my blog. Last week we talked about APIs in Activity 12 and I want to go more in depth about APIs and what a REST API is since I don’t really know what they are. API stands for Application Programming Interface and it is a set of definitions that allows two applications to talk to each other. Almost every application uses an API to communicate data from your device to a server. The server has its own APIs to receive that data and interpret it, and then send it back to your device. Then the application translates that data into a readable format for you. You do not have to know how they are implemented into your application, which can simplify the application development and save a lot of time. APIs can also give security by only allowing certain data through and not all the data. For example, when you buy an item on an online store, you tell the store what items you want to buy and the store tells you what you need to pay. No other information from either your device or the website’s databases is transferred over. What I find interesting about APIs is how they work in video games. There can be multiple APIs in a game that each do something different, such as managing a game’s sound, rendering, and graphics, while others manage AI tasks such as path-finding. Pokemon is one of the most popular video game series out there and there is an API called “Poke API” that has every single Pokemon listing with moves, types, and weaknesses as well as every item in the games. A Pokemon website can use that API to easily get the latest updated information about Pokemon and the games.

REST API or RESTful API stands for Representational State Transfer API. It usually takes advantage of HTTP when used for Web APIs. This means that developers do not need to install libraries or additional software in order to take advantage of a REST API design. However, not all APIs can be REST APIs. In order for an API to be RESTful, it has to follow certain criteria. The client and the server should be separate from each other and allowed to evolve individually and independently, meaning making changes to the database won’t affect the clients. Stateless client-server communication, meaning no client information is stored between get requests and each request is separate and unconnected. Cacheable data that streamlines client-server interactions. A uniform interface which lets the client talk to the server in a single language, standardized means of communicating between the client and the server. A layered system that organizes each type of server. And lastly, Code-on-demand, which is the ability to send executable code from the server to the client when requested. All of these define what REST APIs do.

https://www.redhat.com/en/topics/api/what-is-a-rest-api

From the blog Comfy Blogging by and used with permission of the author. All other rights reserved by the author.

Week-6

Hello, I want to write this blog after finishing my exam like an hour ago; I am looking over some class activities and see any questions to review, but something that sometimes confused me. I read the word “docker-compose” in some class-work exercises; I got interested and looked it up again. I found two links that helped me understand what Docker Compose does and how you use Docker Compose?.

Docker Compose: Run multiple containers as a single service or extend many different Docker containers midway. Even an essential tool for any application that needs various micro-services, as it allows each service to be in a separately managed container easily.

What Does Docker Compose Do?

Docker containers are running applications in an isolated environment. Its application deployments are arranged in Docker for the benefit. However, it’s often complex as running a single container. Usually, Many containers come together to act as one service made up of many changing parts.

Running all deployment time is disordered, so Docker provides Docker Compose; it runs multiple containers to clean it up. It helps all arrangements in one YAML file and starts all the containers with one 

command.

Rather than having all services in one big container, Docker Compose allows to split them up into individually manageable containers. This is better for building and deployment, and it can manage all of them in separate codebases and doesn’t need to start each container manually.

Using Docker Compose is a three-step process:

  • Build the part images using their Dockerfiles, or pull them from a registry.
  • Set all of the component services in a docker-compose.yml file.
  • Run all of them together using the docker-compose CLI.

Docker Compose still builds and publishes Docker containers using a Dockerfile. But, instead of running them directly, it can use Docker Compose to manage the configuration of a multi-container deployment.

How Do You Use Docker Compose?

The form for a docker-compose file is done in docker-compose.yml. It doesn’t need to place this at the root of a project like a Dockerfile. It can go anywhere as it doesn’t depend on any other code. However, it builds the images locally and will need to go into a project folder with the produced code.

A Compose configuration file that runs a WordPress instance using the WordPress container off the Docker Hub. However, this depends on a MySQL database, which Composes also creates.

  • First, a version number since the arrangement can change depending on which version.
  • Next, A list of Services. 
  • Lastly, the volumes are stored.

From the blog Andrew Lam’s little blog by and used with permission of the author. All other rights reserved by the author.

YAGNI.

Hello and welcome back to my blog! In this blog, I want to discuss YAGNI, which stands for “Ya ain’t gonna need it” or “You aren’t gonna need it.” My professor for CS-343 briefly mentioned it in class one day and I wanted to go over it more in depth. In the past, I’ve done something in my projects where I should have followed the concept of YAGNI instead. I made several methods to change a variable before I actually made the main methods of what that variable would do. In the end, it turns out the methods I made were useless toward my goal and I lost a lot of time. I hope to start applying the concept of YAGNI to my future programming in order to not waste time.

YAGNI is a really important concept in programming. Basically it means programmers and developers should only implement classes, methods, or whatever things they need only when they need them. By doing this, you can avoid doing unnecessary work and save a lot of time. When you think ahead and try to code a class or method that you think you will need in the future, it can be hard to know what exactly you need to include in it. The programmer has to do a lot of guessing and for a lot of the times, they guess incorrectly and end up not needing the feature that they spent some time on in the end. By following the concept of YAGNI instead, you don’t have to do all that guessing work and are also more focused on your current task. You should only develop things that you need once they become relevant. In a large project, YAGNI is especially beneficial for programmers and developers. Let’s say a programmer wants to design a feature they know they might need but aren’t sure if they need it or are unclear of how to implement it. By postponing the development of that feature, it can be more clear to the programmer/developer what they exactly need to do for that feature once it becomes relevant again. You should always ask yourself if the feature you are working on is really needed at the current moment. If it’s not needed, then you can take a note of it instead and come back to it later once it becomes relevant again. That way, you keep the project more simple and you program the features better since they are relevant and you have a more clear understanding of what to implement. And the most important thing, you save a lot of time with YAGNI.

 

Source: http://c2.com/xp/YouArentGonnaNeedIt.html

From the blog Comfy Blogging by and used with permission of the author. All other rights reserved by the author.

week-3

Hello,

I am doing some class activities and looking over some questions ahead to save time for a thing or two. I came across the word “Behavioral Patterns” in class Act. 4 (Model 8); I got curious and looked it up. I found two articles that helped me understand the purposes, Problems with solutions, Real-World Analogy, Structure, Pseudo-code, Applicability, How to Implement, Pros and Cons, Relations with Other Patterns.

The Behavioral Patterns are concerned with providing solutions. It is about object interaction – how they communicate, how some are dependent on others, how to separate them to be both dependent and independent, and give both flexibility and testing capabilities—also, the assignment of responsibilities between objects.

The Behavioral Patterns cover many small parts to form the full extend of patterns. Like Interpreter, Template Method/Pattern, Chain of Responsibility, Command, Iterator, Mediator, Memento, Observer, State, Strategy, and Visitor.

Interpreter

The Interpreter pattern: Evaluate any language grammar or expressions. An excellent example; this pattern would be Google Translate, which deciphers the input, and shows us the output in another language. Another example would be the Java compiler. The compiler interprets Java code and translates it into byte-code that the JVM uses to perform operations on the device it runs on. Also, it represents a great way to write simple programs that understand human-like syntax. 

Chain of Responsibility – pass requests along a chain of handlers. Upon receiving a request, each handler processes the requestor gives it to the next handler in the chain. 

Command – Turns a request into a stand-alone object that contains all information about the proposal. This transformation lets pass requests as a method arguments, delay or queue a request’s execution, and support undo-able operations. 

Iterator – traverse elements of a collection without exposing its underlying representation (list, stack, tree, etc.)

Mediator – it reduces chaotic dependencies between objects. The pattern restricts direct communications between the entities and forces them to collaborate only via a mediator object.

Memento – it saves and restores the previous state of an object without revealing the details of its implementation.

Observer – define a subscription mechanism to notify multiple objects about any events to the observed entity.

State – lets an object alter its behavior when its internal state changes. It appears as if the thing changed its class.

Strategy – define a family of algorithms, put them into a separate class, and make their objects interchangeable.

Template Method – the outline of an algorithm in the super-class but lets sub-classes revoke exact steps of the algorithm without modifying its structure.

Visitor – It separates algorithms from the objects on which they operate.

 

From the blog Andrew Lam’s little blog by and used with permission of the author. All other rights reserved by the author.

Just A Refresher For OOP Concepts

Hello and welcome back to my blog! I had a really fun time during the first few weeks of the semester and I am looking forward to the rest of it. The first POGIL group activity we did caught me off guard since I did not remember what the terms abstraction, encapsulation, polymorphism, and inheritance meant. These concepts were taught in one of the earlier programming classes and I have done school projects and labs that involved these concepts in the past. But I don’t actually remember the terms or the clear cut definitions of them. Maybe part of the reason why I did not remember them is because we briefly went over those topics and we were also not forced to remember them since those classes were more about if you could write the code correctly. So that is why I decided to focus my blog around those four concepts. The in-class activity was a good refresher but I wanted to do research to fully have a firm understanding of them. Having a strong understanding of these concepts will help me later on in my computer science journey since these concepts are going to be seen over and over again in object orientated programming.

Let’s start with abstraction. Abstraction is basically hiding unnecessary details and leaving only the necessary and relevant details. Hiding unnecessary information is useful because, well, it is not needed to show that information to the user. An example in real life is your smart phone. All that’s important to the user is the screen and they do not need to know what processor or how much RAM the phone has.

Encapsulation is bundling data with the code that modifies the data and it can also prevent outside sources from accessing that data. In Java, encapsulation is used in classes where data can be declared as private and outside methods cannot access that data.

Polymorphism is the ability to take on many forms. In Java, that means you can perform one tank many ways. An example of that is calculating the area of a shape. You can use the same method area() to calculate the area of a triangle, octagon, or any other shape. There’s also overriding methods where the child class has the same method as the parent class.

Inheritance is gaining the properties of one class to another class. It’s like a parent-child relationship. In Java, a child class inherits all the methods and attributes from its parent class. The vehicle example is a really good one. Vehicle would be the parent class and car and truck would be the child classes. Both car and truck would share the same attributes from vehicle but also have their own attributes as well.

This has been a good review for me and the website really helped me understand what the four OOP concepts are. In the future I hope to apply all of these concepts into my work.

Site used: https://www.nerd.vision/post/polymorphism-encapsulation-data-abstraction-and-inheritance-in-object-oriented-programming

 

From the blog Comfy Blogging by and used with permission of the author. All other rights reserved by the author.

weekly blog (week one)

Hello, Everyone. How are you guys doing?

This past week, I read some articles or news related to CS (Computer Science). I finally picked a topic that caught my attention; engineers create 3D-printed objects that sense how users interact. My reason for why and seeing how choosing this article is because it looks cool and relatable for Gamers to use any controller made of small rubber pieces. 

 

Short Summary: The researchers found a way to combine sensing capabilities into 3D printable structures made of constant cells, enabling designers to prototype interactive input devices quickly. Even, Formed a new method to 3D print mechanisms that detect how force applies to an object. Or The structures are made from a single piece of material so that they can be rapidly prototypes. Also, A designer could use this method to 3D print “interactive input devices,” as a joystick or a controller.

For accomplishing the goal, the researchers blended electrodes into structures made from metamaterials (The materials split into a grid of duplicating cells). Also, They designed editing software that benefits users develop these interactive devices.

First, The researchers need embedded electrodes because a grid of cells creates the metamaterial. That benefits from the user implement strength to a metamaterial object; cells can spread or reduce with few adjustable interiors. They also take advantage by creating “conductive shear cells,” adjustable cells with two opposing walls made from the conductive wire and two walls made from the non-conductive thread. Even, The conductive walls operate as terminals.

When a user implements strength to the metamaterial mechanism, it running a joystick grip or pressing the buttons on a controller. The conductive shear cells expand or decrease. Even, The distance and overlaying area between the opposing terminals changes. While using capacitive sensing, those adjustments can be measured and used to calculate the magnitude and direction of the applied forces and rotation and acceleration.

For demonstration, the researchers built a metamaterial joystick with four conductive shear cells embedded around the base of the handle in each direction. Also, moving around the joystick handle, the distance and area between the opposing conductive walls change to sense each applied force’s direction and magnitude. By learning how joystick users use strength, a designer could test different handles from shapes and sizes for people with faulty grip strength in specific ways.

Second, The researchers created a sensitivity controller designed to adapt to a user’s hand. When the user holds one of the flexible buttons, conductive shear cells within the structure can diminish and send sense input to a digital synthesizer. Also, This method could allow a designer to instantly create and tweak differently adjustable input devices for a computer.

Lastly, MetaSense, the 3D editor the researchers improved, enables this fast prototyping for a software solution. The users can manually combine into a metamaterial device or let the software automatically place the conductive shear cells in optimal locations. The researchers attempted to make MetaSense straightforward, but there are tests for printing such intricate structures.

From the blog Andrew Lam’s little blog by and used with permission of the author. All other rights reserved by the author.

Introductory Post

Hello everyone Angus here. I’ll be entering my junior year here. I had a great summer break and hope you guys had a good one too. I’m excited to get back to school and start this semester with happy and chill vibes.

From the blog Comfy Blogging by and used with permission of the author. All other rights reserved by the author.

Introductory Blog Post

Hello, my name is Andrew Lam. I am currently a college student getting a CS (computer science) bachelor’s degree. Also, looking forward to the steps and experiences throughout this journey or exciting facts or opinions that could give some feedback or pointers.
 
Hoping Meeting interesting or any people for common interest as myself

From the blog Andrew Lam’s little blog by and used with permission of the author. All other rights reserved by the author.

Sprint 3 Retrospective

 Links to evidence of activity on GitLab.

This is my frontend user interface for the report team

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/generatewcfbreportfrontend

I updated my frontend from sprint 2 in my local service which I used the sample frontend example from the professor. I have changed the background and move the start date and end date in the middle same as the common website let the user input the login information. 

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/reportingbackend

Austin and I connected the backend API to my frontend API, which can let customers download the report for the inventory. It got succeed download the report for the inventory when we connect the API together.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/community/-/issues/35

My frontend design idea is based on the Worcester State University style of design. For the background picture and the color use, I followed the handbook of WSU style of design.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/community/-/issues/67

I implemented FrontEnd for reporting with the most recent version.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/community/-/issues/55

We Made some OpenAPI.yaml files for our FrontEnd and BackEnd.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/community/-/issues/66

We looked over TheasPantryReport.

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem/community/-/issues/71

We looked at the new architecture and plan accordingly.

Reflection on what worked well?

In Sprint 3, in terms of what worked well, the second phase was more efficient when team members worked together than ever before in completing the project plan. After a semester of teamwork, we have a deeper understanding of our ultimate goal and become more accustomed to each other’s habits. There will be a relaxed working atmosphere, and the team chemistry will encourage each other to push the project forward. The project progressed more smoothly, and the ZOOM meetings of the team were relatively frequent.

Reflection on what didn’t work well?

As for why it didn’t work out, there is a longer-term vision of the end product and the project’s future goals. Unfortunately, we failed to get the data of other groups. We made test data to run our report program. In addition, the team members were busy with other courses at the end of the semester, so there were some deficiencies in the adjustment of time in the later period. We had some confusion in the front end and back end docking. Through learning external materials and teamwork, we successfully solved the docking problem. Fortunately, we made timely adjustments and promoted the project objectives, and completed the group project.

Reflection on what changes could be made to improve as a team?

As a team with cooperation, smooth communication, and tacit understanding among team members are the basis and key to improving our team’s cooperation level. We would discuss the project after class and give some constructive suggestions about each other’s tasks. Good communication makes our team have chemistry. Through communication and cooperation, we have a thorough understanding of the team members’ tasks. Each knew the other’s project progress would be conducive to the overall advancement of the project. When a team member encounters a bottleneck in a task, we will appropriately slow down the overall progress and communicate with him to buffer his time to complete and push forward the overall task progress.

Reflection on what changes could be made to improve as an individual?

As an individual, I have watched and learned a lot about front-end production after class. It improves my front-end understanding and production skills, which helps my team better connect the front-end to the back-end. In this project, I learned and improved some problems encountered in team cooperation and realized the power of the team in finding and solving problems. In a team, the mutual understanding and tacit understanding among team members is the basic condition for the smooth operation of a team. It was a great honor for me to meet every team member in my last year of university, and I learned a lot of valuable experience from them in ZOOM meetings. At the same time, I am also very grateful to the professor for giving us an opportunity for a big team project, which benefited me greatly. I believe that I will bring my learning experience to my team in future team cooperation projects. Finally, I’d like to thank Worcester State University. It’s my great honor to be a member of the computer major.

From the blog haorusong by and used with permission of the author. All other rights reserved by the author.

Sprint 3 Retrospective

https://gitlab.com/LibreFoodPantry/client-solutions/theas-pantry/reportingsystem

Here is the Link to the repositories that contains everything we worked on Sprint-3. Backend, Frontend, Event system, and Keycloak.

Connect RabbitMQ receive file to DB: Connected the MongoDB database on the received file.

Implement Event System components: Implemented RabbitMq components for Event System.

Meet with other Event System Teams.: Met with other teams to finalize everything about messages.

New TheasPantryReport: The new Theas Pantry Report

Create two channels for both teams: Created two channels for both teams on the send and receive files.

 

For this Sprint, I worked mainly with Austin on the backend components such as implanting the rabbbitMQ, making API, and trying to get out system working.

What worked well / did not work well

For this sprint, what worked best was that we got our reporting system functioning. We have a system where the Rabbitmq receives the message from the queue and saves it in a database. From there the backend takes the data and converts it into a CSV so when the Frontend requests for a report the backend can send that CSV file to the user. One of the key things that I noticed that our group works well under pressure. We are always calm and composed. I don’t think there is something that did not work well, however, we should have managed our time wisely since the end of the semester was filled with many assignments.

What changes could be made to improve as a team?

As a team, this was our final sprint for the semester. In the future, if we work on this, I think it Is important to use the time wisely as we were up on zoom every night to make little progress towards the project. Also, whenever we had a question, we should have posted more on the issue board or could have asked the professor for more help but as a team, I’m so proud and happy with the way everything turned out towards the end.

 What changes could be made to improve as an Individual?

As an Individual, I should be communicating with my team more rather than just doing the issues that are assigned to me. I should try to manage my time wisely too. The end of the semester was a struggle since there were exams and projects from every class. I believe that we could have made our system more efficient and functional, but it turns out to be what I imagined from the starting. Working together as a team doing one task at a time was efficient for me and as a group.

Overall, this was a great learning experience. I will never forget this class or the reporting team. It was a pleasure working with amazing teammates who pushed me to move forward whenever I was struggling on an issue. I hope that the experience I got from the capstone will be a highlight for my future career in the field of technology. I wish all of you the best of luck and congrats on your graduation. Hopefully one day we can look back and enjoy these moments.  

From the blog Derin's CS Journey by and used with permission of the author. All other rights reserved by the author.