Hello
blog (mood-status: feeling Good), writing this blog after thanksgiving
dinner and eating well like pretty good with a plate of food alongside
hanging the family. But anyway, on writing about this week-11. To be
truthful here, I writing this because I am falling behind on blogs when
there is nothing to talk about, besides kept being busy with other
courses like HWs and projects, etc. (You get the point. Well, if you are
a student) 

I decided to go on the Syllabus to look at the course topics.

I found the subject of Modeling along with Unified Modeling Language (UML) & C4 Model.

Unified Modeling Language

Large
Companies’ applications that execute core business applications and
keep a company going can more than some code modules. It can structure
in a way that enables:

• scalability
• security 
• robust execution under stressful conditions. 

Their structure is that maintenance programmers can find and fix a bug
that shows up after moving on to other projects. These programs can
design to work perfectly in many areas, and business functionality is
not the only one. A well-designed architecture benefits any program, and
not only the largest ones as singled out. It mentioned large
applications first because the structure deals with complexity, so the
benefits of the network compound as the application size grows large. 

Another use of a structure that enables code reuse was design time.
Ultimately, companies build up models of parts, each unit representing
an implementation stored in code modules. At coding time, the developer
can as promptly import the code module into the application. When
another application needs the same functionality, the designer can
quickly import its module from the library.

The C4 model

The
C4 model made by Simon Brown designates on UML and the 4+1
architectural view model. It breaks down software into smaller units for
modeling. Like the quick methodology, the C4 model requires fast,
efficient sharing and constant updates of software architecture in
software development.

The
C4 model (shown as a map). The Maps can build on a different scale. By
changing scales, like for example; The town map with streets and
buildings. Having the C4 model changes the level of a diagram to
describe software architecture. Using the abstraction-first approach, C4
conducts modeling top-down from system context to lower levels.

• Person (Element) – users or roles of a software system
• Software
  system (topmost level in abstractions) – the value of existing systems
  or systems under development and the interaction between those systems
• Container
  (Element) – the internals of software systems, usually applications or
  solutions for data storage. A different concept to containers in Docker.
  It mainly refers to software that is single deployed.
• Component (Abstraction element) – The containers of modules or a set of interfaces grouped as a functional unit.
• Relations – dependencies or data flow between abstraction elements.

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

Hello
blog (mood-status: feeling Good), writing this blog after thanksgiving
dinner and eating well like pretty good with a plate of food alongside
hanging the family. But anyway, on writing about this week-11. To be
truthful here, I writing this because I am falling behind on blogs when
there is nothing to talk about, besides kept being busy with other
courses like HWs and projects, etc. (You get the point. Well, if you are
a student) 

I decided to go on the Syllabus to look at the course topics.

I found the subject of Modeling along with Unified Modeling Language (UML) & C4 Model.

Unified Modeling Language

Large
Companies’ applications that execute core business applications and
keep a company going can more than some code modules. It can structure
in a way that enables:

• scalability
• security 
• robust execution under stressful conditions. 

Their structure is that maintenance programmers can find and fix a bug
that shows up after moving on to other projects. These programs can
design to work perfectly in many areas, and business functionality is
not the only one. A well-designed architecture benefits any program, and
not only the largest ones as singled out. It mentioned large
applications first because the structure deals with complexity, so the
benefits of the network compound as the application size grows large. 

Another use of a structure that enables code reuse was design time.
Ultimately, companies build up models of parts, each unit representing
an implementation stored in code modules. At coding time, the developer
can as promptly import the code module into the application. When
another application needs the same functionality, the designer can
quickly import its module from the library.

The C4 model

The
C4 model made by Simon Brown designates on UML and the 4+1
architectural view model. It breaks down software into smaller units for
modeling. Like the quick methodology, the C4 model requires fast,
efficient sharing and constant updates of software architecture in
software development.

The
C4 model (shown as a map). The Maps can build on a different scale. By
changing scales, like for example; The town map with streets and
buildings. Having the C4 model changes the level of a diagram to
describe software architecture. Using the abstraction-first approach, C4
conducts modeling top-down from system context to lower levels.

• Person (Element) – users or roles of a software system
• Software
  system (topmost level in abstractions) – the value of existing systems
  or systems under development and the interaction between those systems
• Container
  (Element) – the internals of software systems, usually applications or
  solutions for data storage. A different concept to containers in Docker.
  It mainly refers to software that is single deployed.
• Component (Abstraction element) – The containers of modules or a set of interfaces grouped as a functional unit.
• Relations – dependencies or data flow between abstraction elements.

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

Hello
blog (mood-status: feeling Good), writing this blog after thanksgiving
dinner and eating well like pretty good with a plate of food alongside
hanging the family. But anyway, on writing about this week-11. To be
truthful here, I writing this because I am falling behind on blogs when
there is nothing to talk about, besides kept being busy with other
courses like HWs and projects, etc. (You get the point. Well, if you are
a student) 

I decided to go on the Syllabus to look at the course topics.

I found the subject of Modeling along with Unified Modeling Language (UML) & C4 Model.

Unified Modeling Language

Large
Companies’ applications that execute core business applications and
keep a company going can more than some code modules. It can structure
in a way that enables:

• scalability
• security 
• robust execution under stressful conditions. 

Their structure is that maintenance programmers can find and fix a bug
that shows up after moving on to other projects. These programs can
design to work perfectly in many areas, and business functionality is
not the only one. A well-designed architecture benefits any program, and
not only the largest ones as singled out. It mentioned large
applications first because the structure deals with complexity, so the
benefits of the network compound as the application size grows large. 

Another use of a structure that enables code reuse was design time.
Ultimately, companies build up models of parts, each unit representing
an implementation stored in code modules. At coding time, the developer
can as promptly import the code module into the application. When
another application needs the same functionality, the designer can
quickly import its module from the library.

The C4 model

The
C4 model made by Simon Brown designates on UML and the 4+1
architectural view model. It breaks down software into smaller units for
modeling. Like the quick methodology, the C4 model requires fast,
efficient sharing and constant updates of software architecture in
software development.

The
C4 model (shown as a map). The Maps can build on a different scale. By
changing scales, like for example; The town map with streets and
buildings. Having the C4 model changes the level of a diagram to
describe software architecture. Using the abstraction-first approach, C4
conducts modeling top-down from system context to lower levels.

• Person (Element) – users or roles of a software system
• Software
  system (topmost level in abstractions) – the value of existing systems
  or systems under development and the interaction between those systems
• Container
  (Element) – the internals of software systems, usually applications or
  solutions for data storage. A different concept to containers in Docker.
  It mainly refers to software that is single deployed.
• Component (Abstraction element) – The containers of modules or a set of interfaces grouped as a functional unit.
• Relations – dependencies or data flow between abstraction elements.

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

In my previous entries, I have been taking topics (such as REST APIs, coding smells, and so on) and merely providing general applications of the subject. This is not to say that the posts are simply summaries; rather, they provide a little bit of coverage on a lot of ideas within the subject. This time, I’m going to something a little different – I want to cover a specific issue involving REST API calls. This issue involves the return messages from the calls, specifically the “200” success message vs. the “404” failure message.

To summarize, a “200” return message is essentially an “OK” message. It means that, when trying to access data, that data can be found to some degree (even if its value is zero). For example, even when trying to access an empty list, it will return a “200” despite having no items within the list. In contrast, a “404” error is commonplace on the internet, to the point where even those who aren’t tech-savvy at least understand the general idea – it means that requested data cannot be found. in short, it doesn’t exist (at least not to the server).

A good way of discerning the difference between these two is to take a shelf of soup cans. If we have an empty shelf, then we will get a “200” message – the shelf exists, but there are no soup cans on it. Meanwhile, a “404” would mean that we cannot get any soup because the shelf does NOT exist.

The blog associated with this reading is short, sweet and to-the-point; it briefly explains the “200” and “404” messages, alongside some other return messages (and even some images of cats!) I chose this reading due to its brief, yet informative nature – these topics are not difficult, and don’t require too much explaining. The cats also make for a humorous touch, allowing the learning process to be more “fun” and “easy going”.

While a smaller detail, this distinction between “zero” and “null” is not to be taken lightly. I plan on using this knowledge in future practice, as it will reinforce good coding practices; it is not enough to say “we have no soup” and be done with the problem. We need to know exactly WHY we don’t have any soup, otherwise this faulty coding can lead to smells and other issues down the road. It is always important to not only understand what the result of a program is, but also how it gets that result. We also need to ask ourselves if this result is obtained “properly” – meaning that it is done in a way that works smoothly with the res of the program.

Link: https://blog.short.io/status-codes/

From the blog CS@Worcester – mpekim.code by Mike Morley (mpekim) and used with permission of the author. All other rights reserved by the author.

https://www.altexsoft.com/blog/front-end-development-technologies-concepts/

The frontend of an api or web system is the visual representation/interface that is seen and used by visitors, customers, etc. You interact with the frontend through your browser so frontend development is very important for any online website or service. When creating the frontend of a system the developers use HTML, CSS and Javascript which are the same tools used to make web apps. Frontends are very different from backends as the user does not see the backend or really necessarily interact with it. The backend is what happens on/in what it is developed for. Backends govern the functions and any operation that takes place within the system.

Backends are developed using different languages based on the developer or customers preferences. The backend also consists of the web server and storage of the system which it supports. But even though the backend contains what makes the site/app function, the front end is still just as important as it is what is presented directly to the users. Through mainly html front ends bring the actual user experience into play and help to dictate the functionality of a website even though the frontend is not directly involved in the execution of the functions.

I chose this article as it was very helpful when it comes to understanding what exactly a front end is and why it is important when developing something such as an app or website as it truly is the entire user experience. The user experience overall can make or break an app or any other type of programming which requires a front end and therefore the front end development process is very important.

I feel as though an article like this would be helpful not only to myself but to my peers as it thoroughly explains what a front end is as well as what a backend is. This helps fully differentiate the two so that there is no confusion in the development stages of either. Both frontends and backends are similar but also drastically different in how they are developed and the purpose they serve. This article helps to differentiate the two and helps the reader gain an understanding of what is included in each in order to develop an effective system that thrives for both the developers of the system and the users of the system. I would recommend this article to anyone questioning the difference between frontend and backend as well as anyone wondering how to develop an effective api in general.

From the blog CS@Worcester – Dylan Brown Computer Science by dylanbrowncs and used with permission of the author. All other rights reserved by the author.

While I was seeking an internship, I had run into a great friend who currently works as a software developer. He mentioned this method which is called CI/CD and told me that this is a great way to develop, deploy and maintain software that developers should know about. Following his world, I’ve done research about this topic and found what he said was entirely true. For developers who want to learn more about the software development process, this blog is for you. This blog is going to focus on what is CI/CD and what it does to the software development life cycle.

CI/CD is a method to frequently deliver apps to customers by introducing automation into the stages of app development. There are three main concepts developed to CI/CD are continuous integration, continuous delivery, and continuous deployment. CI/CD is a perfect solution along with Docker to solve the problem that new code can cause for development and operation teams. CI/CD introduces automation and continuous monitoring throughout the life cycle of apps, from integration and testing phases to delivery and deployment. This practice is referred to as “CI/CD pipeline” and is supported by development and operation teams working together in a responsive way to have the best approach.

CI/CD is also a software engineering practice where members of a team integrate their work with increasing frequency. To do so, teams strive to integrate at least daily and even hourly, approaching integration that happens continuously. CI emphasizes automation tools that help build and test, finally ultimately focusing on achieving a software-defined life cycle. CI is successful, build and integration effort drops, and teams can detect errors as quickly as practical. CD is to be packaging and deployment what CI is built and tested. A team can build, configure, and package software as well as rewrite its deployment to fit with its budget at any given time. As result, customers have more opportunities to experience and provide feedback on changes.

Continuous integration helps developers merge their code changes back to a shared branch, more frequently- sometimes even daily. Once the changes are merged, those changes are validated by automatically building the application and running through many levels of testing to ensure changes have not broken the app. CI makes it easier to fix bugs as quickly and often as possible.

While in continuous delivery, every stage-from the merger of code continuously changes to the delivery of production-ready builds-involves test automation and code release automation. The goal is to have a code-base that is always ready for deployment to a production environment.

Those things above are some benefits of CI/CD and personally, I found it very interesting to me as a future software developer. I think this method would help developers to maintain the best of their system as well as the foundation of security.

Source:

https://www.redhat.com/en/topics/devops/what-is-ci-cd

From the blog CS@Worcester – Nin by hpnguyen27 and used with permission of the author. All other rights reserved by the author.

Over the past week, as we were talking about APIs and working on the backend to web applications, I was wondering about how the front end of these applications actually interacts with the backend software that we were working on. So I looked for something to help aid my understanding of frontend and backend interactions. In doing so, I found a post on vsupalov.com called How Does the Frontend Communicate with the Backend? that covers this area of web design.

While there is little discussion of APIs and their use in this process, I still think it is important to understand how the frontend and backend of a server interact in order to get a complete picture of how web applications work. The post starts off by explaining the basics of how the structure works and the definitions of terms, with the frontend being made of mostly HTML, CSS, and some JavaScript, and being run on the browser, which mostly interprets and renders data received from the backend. The backend receives HTTP requests from the frontend and compiles data to be sent and rendered in the frontend. The post then explains how these two components interact, through the packaging and sending of HTTP requests and responses. These generally are in JSON format, but could just be HTML, images, or any other files or codes. The final part of the post gives examples of how these systems work together to bring about the best possible user experience, by using the speed of the backend running on a host server to process how the user views a site, without having to use the much slower and choppier processing speed of the browser application. These examples include interacting with databases and how sites can render information server-side for SEO or performance reasons.

When I was working on websites, this kind of architecture would have saved me and the company a lot of time, I spent countless hours reducing the size of pictures to improve website performance, all of which could have been saved by using HTTP requests to dynamically load images when they were needed from a backend database. And the role of APIs in this process cannot be understated, facilitating this transfer of information between frontend and backend through properly formatted requests and responses. This gave me a much more clear understanding of how the interactions between the frontend and backend of web applications are processed, and why it is such an important part of proper web design. In the future, I feel that this information will help me have a better grasp of how these systems work, and how to properly utilize them to create better user experiences online.

Source: https://vsupalov.com/how-backend-and-frontend-communicate/

From the blog CS@Worcester – Kurt Maiser's Coding Blog by kmaiser and used with permission of the author. All other rights reserved by the author.

            When the topic of interfaces is brought up, the concept of User Interfaces tends to come to mind more times than not, given how we tend to utilize interfaces to exchange information between an end-user and a computer system by providing an input request and receiving data as an output result. Simply put, we often think of interfaces as the (often visual) medium of interaction between a user and an application. While this is true, such interactions are not limited between end users and applications, as it is possible for other applications to interact with other applications by sending or receiving information to each other to carry out a certain function. Such interface is an Application Programming Interface (API), which is a set of functions used by systems or applications to allow access to certain features of other systems or applications. One such case is the use of social media accounts to log-in to one’s Gitlab account, in this case Gitlab’s API will check if a certain user is logged into a specified social media account and has a valid connection first before allowing access to a Gitlab account. For this blog post, I want to focus on mostly web APIs.

            There are, however, three different architecture styles, or protocols, used for writing APIs, therefore there is not once single way of writing the API that an application will use, and different advantages and trade-offs need to be considered when choosing a specific API protocol as the standard for an application. The styles used for writing APIs are the following:
1. Simple Object Access Protocol (SOAP)
2. Remote Procedural Call (RPC)
3. Representational State Transfer (REST)

Among the above protocols, REST seems to be the most widely used style for writing APIs. REST provides the standards constraints utilized for interactions and operations between internet-based computer systems. The APIs of applications that utilize REST are referred to as “RESTful APIs” and tend to utilize HTTP methods, XML for encoding, and JSON to store and transmit data used in an application. Although writing RESTful APIs cannot exactly be considered as programming in the same way writing an application in JAVA is, such APIs still utilize some level of scriptwriting and creating endpoints for an API still utilizes specific syntax when specifying parameters and what values they must contain. One article that I came across when researching tutorials is titled A Beginner’s Tutorial for Understanding RESTful API on MLSDev.Com uses an example in order to show how RESTful architecture design works for RESTful APIs. In this example, the author Vasyl Redka, proceeds to show an example of a response to a request, which HTTP methods and response codes are utilized, along with how Swagger documentation is utilized when writing APIs.

            Though RESTful API may be somewhat confusing at first due to how the approach of writing APIs differs to the approach used for writing code, being able to effectively write APIs for web-based applications can be a rather significant skill for web-based application development.

Direct link to the resource referenced in the post: https://mlsdev.com/blog/81-a-beginner-s-tutorial-for-understanding-restful-api

Recommended materials/resources reviewed related to REST APIs:
1) https://www.redhat.com/en/topics/api/what-is-a-rest-api
2) https://www.ibm.com/cloud/learn/rest-apis
3) https://www.tutorialspoint.com/restful/index.htm
4) https://spring.io/guides/tutorials/rest/
5) https://searchapparchitecture.techtarget.com/definition/REST-REpresentational-State-Transfer
6) https://www.developer.com/web-services/intro-representational-state-transfer-rest/
7) https://www.techopedia.com/definition/1312/representational-state-transfer-rest
8) https://searchapparchitecture.techtarget.com/tip/What-are-the-types-of-APIs-and-their-differences
9) https://www.plesk.com/blog/various/rest-representational-state-transfer/

From the blog CS@Worcester – CompSci Log by sohoda and used with permission of the author. All other rights reserved by the author.

For this week’s blog post I have found a blog on Unified Modeling Language (UML). UML is an object-oriented modeling language. This has become a normal standard for documentation of a software system. It is a pictorial description of classes, objects, and relationships. It represents a plan that defines the working hardware or software system. For example, we can use a UML diagram to show what is going on in a three-class software system. For this example, the names of the three classes will be Student, Classroom, and Teacher. For each class, a box is used in UML to show the entire class with three lines separating class name, methods, and instance variables. Each variable is listed as the variable type and name separated by a colon (for example, String : Id). While the methods are listed as method name with parameters (if any) and the return variable type (if any) separated by a colon (for example, getId() : String)  Now if we wanted to show that the class named Class borrows objects from the student class, we would draw a arrow pointing from student to Class. If we wanted to show that it extends the class, we would draw a dotted arrow instead.

UML was designed and created back in the 90’s. This was a period where object-oriented languages (OOL) such as C++ were being used to build complex but compelling systems. The issue during this time was that we had complex systems but no good way of showing on paper what the system is doing. This was until in 1994 when software engineers Grady Booch, Ivar Jacobson, and James Rumbaugh of Rational Software created the UML language. This development of the language was finished two years later in 1996. Each of the designers came together to find a language they will reduce the complexity. According to Study Section, the website with the blog, they say on their process of reducing this complexity, “Booch’s method was flexible to work with throughout the design and creation of objects. Jacobson’s method contributed a great way to work on use-cases. It further has a great approach for high-level design. Rumbaugh’s method turned out to be useful while handling sensitive systems. Behavioral models and state-charts were added in the UML by David Harel.” (Study Section) In 1997, the Object Management Group (OMG) acknowledged UML as a normal language. They now are responsible for maintaining the UML language and updating with new languages that come out.  

From the blog CS@worcester – Michale Friedrich by mikefriedrich1 and used with permission of the author. All other rights reserved by the author.