In our practice with REST API backends, multiple times we ran into MongoDB usage, as the database we were using for the API was MongoDB. My only previous experience had been SQL/SQLite, so I wanted to know what the difference was. I came to find out there is a world of difference, in fact MongoDB is a NoSQL database (NoSQL meaning… well exactly what you would expect it to mean). I found an article – part of a MongoDB tutorial – from Guru99 called Types of NoSQL Databases, What is & Example which dove into the differences and usefulness of MongoDB and other NoSQL databases. Chiefly, NoSQL DB’s do not require fixed schemas, avoid joins, and are easy to scale, which is perfect for distributed data storage and “scaling out”, which is becoming increasingly essential in the CS world. The lack of schema is convenient too, as it allows for “heterogeneous structures of data in the same domain,” providing for great versatility. The other essential parts of NoSQL include it being non-relational and having a relatively simple API. The four kinds are Key-value pair based, column-oriented graph, graph based, and document oriented. Key-value pair based means data is stored in pairs (with a key and a value), which is optimal for large datasets and heavy loads. Column-based means that work is done on separated columns with values in single columns being stored contiguously, performing well with aggregation queries. Document-oriented DB’s (MongoDB is one) also function as a key/value pair, but in this, a value is stored as a document, which is stored in JSON or XML. It is not optimal for high performance or aggregate structures, like Key Value or Column Based. Graph based stores entities and relationships between them. Each entity is a node and each relationships is an edge, defining the relationship. This is different from relational DB’s inn that Graph DB’s are “multi-relational.” NoSQL DB’s commonly query with a key and a GET request. The CAP theorem is also important to NoSQL because it guarantees at most two out of the following three: consistency, availability, and partition tolerance. This is a key limitation of NoSQL DB’s. The last key to NoSQL falls on the concept of eventual consistency, meaning that changes to data on one machine must be reflected on other replicas eventually. Where the standard for RDBMS is ACID, NoSQL is BASE: Basically Available, Soft state, Eventual consistency. The article goes on the list advantages, disadvantages, and summarize itself before coming to a close. I thought this was very interesting to learn, as I can see how different DB styles can reflect the needs of a project or client story. I wasn’t sure why we were using MongoDB; I kind of took it as a given. But this reading broadened knowledge, so now, if I am able to build a REST API of my own over the upcoming break, perhaps I can find the optimal DB for my needs, or help me better understand future projects once I join the workforce.

From the blog CS@Worcester – Marcos Felipe's CS Blog by mfelipe98 and used with permission of the author. All other rights reserved by the author.

https://blog.codinghorror.com/code-smells/

This blog post will center on code smells which was a topic covered in class fairly early on. The reason why I’m going back to it is mainly to refamiliarize myself with the subject since it wasn’t a major topic in class. Code smells are defined by the blog post linked above as general warning signs in code, hence the name. There are different types of code smells that signify different coding problems. For example, long comments, long methods, overly large classes, duplicate code, dead code, inconsistent naming, uncommunicative naming, et cetera. Keep in mind that these issues won’t necessarily stop a program from running, rather they negatively effect on the performance and design levels. Also, all of these different types of code smells share the common trait of not quite looking right when looking at a larger scale. So at first glance the code might seem fine, but given a closer look the flaws whether it be dead code, inconsistent naming, or whatever become readily apparent.

A code smell isn’t something concrete like a detailed recipe, it’s more abstract than that. It similar to a suggestion or a tip and can lead to improving code both on a functional level and a design level. Take for example, noticing the code smells of long comments and dead code which suggest removing the useless code and either simplifying or outright deleting the comments. This will make the code more readable which also improves it on a design level. On the other hand, noticing the code smells of duplicate code and long methods and correcting each issue accordingly will improve the code on a performance level top of the possible design improvements. All of the types of code smells that I listed earlier still hold true but they act as more of a general guideline. There are some scenarios in which some smell types blend together such as long methods and overly large classes to name one. Detecting code smells isn’t going to always be the same in that what someone is looking for will differ every time and the outcome will also differ every time. This process is kind of like trying to find freshly spoiled food; sometimes it looks fine and sometimes you won’t know what exactly you’re looking for. But what you do know is that something smells off and you probably don’t want to risk the chance of getting sick.

From the blog CS@Worcester – Rainiery's Blog by rainiery and used with permission of the author. All other rights reserved by the author.

This post today is about AngularJS based off of the article AngularJS-Overview by TutorialPoint. AngularJS is a structural framework for dynamic web applications that was developed in 2009 by Misko Hevery and Adam Abrons. Its latest version 1.2.21 is now maintained by Google. AngularJS lets you use HTML as a template language and then allows you extend the the syntax to express application components. It is a framework used to build large scale and high performing applications that are easy to maintain. General features include that it is open source and licensed under Apache license version 2.0, it is an efficient framework able to create Rich Internet Applications (Web apps that are able to perform the normal features and functions of normal applications), provides an option to write client side applications using Javascript under an efficient Model View Controller method, and AngularJS is cross-browser compliant so that it automatically handles JavaScript for each browser. The advantages of AngularJS are that it has the ability to make single page applications in a clean way, provides data binding capabilities to HTML giving it a responsive experience, it is unit testable, uses dependency injection, gives the ability to provide more functionality with less code, and it can run on all major browsers and smartphones. The disadvantages are that it is not secure and not degradable. Since it is a framework that is JavaScript only, it is not safe so server side authentication is a must. Also since it is all JavaScript, if the user disables it, the webpage would show nothing but the basic page.

This relates to class because we were looking at the process and components that go into web applications. I selected TutorialsPoint because I have used it before for overviews, tutorials, and references. It has proven to be a reliable source to me so I do not have to worry about getting the wrong information. Their reviews online are typically very well rated with key words such as reliable, useful and helpful. I have found those three keywords to be true with this article. I had learned many things since I did not know much about AngularJS prior to reading the article. Some of these things include that it is very useful for single page applications and that it is not very secure. This is very useful for me to learn about because I am currently planning a single page web application project so it is an option for me to utilize.

Source: https://www.tutorialspoint.com/angularjs/angularjs_overview.htm

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

Today I will be writing about Maven using information from the article Maven-Overview by TutorialsPoint. Maven is a project management tool giving a complete build process framework. Mavens objective is to provide a comprehensive, reusable and maintainable model for projects and to provide plugins and tools to interact with this model. Since Maven uses a standard directory layout and default build lifecycle, development teams can quickly set up their project builds. When you have multiple development teams Maven can create a standard build structure for all teams to use. This promotes consistency across the project while developers create reports, builds and testing automation setups. Maven gives a way for developers to manage builds, documentation, reporting, dependencies, SCMs, releases, distribution and mailing lists. Mavens project structure is declared in in the pom.xml file. POM stands for Project Object Model and contains the fundamentals of the entire Maven system. This pom.xml file is similar to the build.gradle file we have seen/used in class. Some features of Maven include its ability to generate a website or PDF including complete documentation, backwards compatibility, automatic parent versioning so that there is no need to specify in the sub module, parallel builds achieving performance improvements of up to 50%, and improved error reporting.

This topic relates to class because it is a software project management tool, which can be very useful to developers. We often used Gradle in class which is a similar concept. I selected this article from TutorialsPoint because it is a useful website for quick references, overviews and tutorials. It is similar to w3schools which is another website I use often for quick tutorials, references, etc.. I would say that the information is reliable, just more shallow as it does not dive deep into topics. I would not use it as the only source when trying to learn a certain subject in depth as you will not get a deep understanding of the material. As an overview though, I would say it is perfect. I personally had an okay understanding of Maven as I had used it a couple of times but never knew the finer details as to how it is different from other project management tools. Some things I had learned from this article are its many features including its use for reporting and documentation. I plan to use project management tools for future projects, so it is good to know the differences and know which one is the right one to use.

Source: https://www.tutorialspoint.com/maven/maven_overview.htm

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

Sprint 3: 04/08/2020 – 05/04/2020

Sprint 3 preparation started on 04-08-2020. Since Sprint 3 was the final Sprint we were planning to get work done as much as possible. We proposed too many issues that were all appropriate, but we wouldn’t be able to finish them all on time, so we all agreed to keep the most important ones. Our top goal for this Sprint was to have the UpdateGuest service work as a whole.

These are the issues we came up within our Sprint 3 planning (we had more in our backlog):

• Create MongoDB database for UpdateGuestService
• Implement WebUI in Angular App
• Decided which type of Angular form to use for Web UI
• Learn about Angular Testing
• Create endpoints in backend
• Learn how to create tests for backend endpoints
• Learn Docker
• UpdateGuestWebUI: Create Docker Configuration
• UpdateGuestService: Create Docker Configuration
• Implement requested endpoints from registrar team
• Decide what needs to be tested in the frontend
• Implement endpoints in Frontend
• Implement Angular form in WebUI.

 During Sprint 3 I worked in multiple issues and supported the team with issues discussions and merge requests’ review:

1 – This issue was part of Sprint 2, but we had some minor changes that needed to be done before we merged the merge request.

2 – We had to decide which Angular Form we were going to use, and as a team, we decided to use Reactive Forms.

3 – This is issue was more about learning. The first thing learned was that the latest version of Docker cannot be installed in a Windows Home edition unless you are using it as an enterprise. Docker in Action was a great resource to learn Docker.

4 – I have reviewed, approved, and merged the merge request for this issue.

5 – I created the Docker configuration of the UpdateGuestWebUI using the NGINX proxy server, which by default will run at PORT 8080, using the Docker container IP.

6 – We had a couple of merge requests for this issue. I have reviewed the merge requests of my teammates and implemented the Age&Employment component.

What we needed to do less

We should not focus only on the issues we get ourselves assigned to. Reviewing each other’s work is very important.

What worked for us as a team:

• Reviewing each other’s work helped a lot with our progress because of the feedback we gave and received.
• Helping each other through Gitlab Discussions and during our class meetings.
• Checking GitLab constantly as we decided on our working policy helped us be on the same page.

What we need to improve 

There is always something that needs to be improved, especially when the team is determined to constantly make progress and succeed. In our case, we should improve the way we manage our time. 

Conclusion

I think we finished Sprint 3 successfully. We managed to work together even better than Sprint 1 & 2. The reason for that is because we were able to communicate, discuss, share, and collaborate with each other the whole time. In the end, we all feel satisfied and accomplished with the progress our team had.  

From the blog CS@Worcester – Gloris's Blog by Gloris Pina and used with permission of the author. All other rights reserved by the author.

Many times the plan that people have laid out for their lives are almost never the same as what actually happens. In this pattern, A Different Road, the author discusses that sometimes it is okay to step away from The Long Road that you were taking to becoming a software developer. This simply means that its okay to step way from this, whether it be permanent or temporary, you should always carry the skills that you learned with you into whatever it is you do next. Then expanding from that, if you do return, you should keep those unique experiences and bring them back into your next job.

This pattern speaks to me personally because I have had many different jobs ranging from warehouses, Dunkin Donuts, meat shops, landscaping etc. The point being is that I have had the privilege to be able to experience this firsthand. Many of these jobs were basic minimum wage jobs that left me desiring for more, and to be able to actually use my brain. However, these jobs all were able to give me something back that I have been able to carry with me throughout my life. For example, most of these jobs gave me the motivation to constantly be trying to reach a better place in life and work. I know how it feels to be sitting in a job and feel like my brain is melting from boredom. Going through these times grants me the motivation to not have to return to them.

The pattern also discusses that often times with a desired job in the software field, HR will see the other jobs as simply lack of experience. However, through the many jobs that I have had it is very obvious to me that this does not constitute for lack of experience because all jobs tie together in different ways. Because I simply was not doing software strictly at the time, does not mean I am not capable of a software job. This is where it all ties back to the pattern. If you are able to take away good, beneficial lessons from where ever you are, you simply have to be able to prove these “skills” to whoever is doubting you.

From the blog CS@Worcester – Journey Through Technology by krothermich and used with permission of the author. All other rights reserved by the author.

The final Apprenticeship pattern I would like to discuss is titled “Draw Your Own Map.” This pattern is written for developers who feel that none of the career paths their employer provides is a good fit for them. It reminds us that it is up to ourselves, not our employers or anyone else, to determine what the next step in our careers should be. The pattern recommends that we develop possible career maps made up of small, specific steps we want to achieve. If our maps conflict with our employers’ expectations, we should simply seek out other opportunities that better fit. These maps are never set and can be altered as our circumstances change, but they will always help guide us towards the career we want.

As I’ve gotten closer to finishing college, I’ve become increasingly worried about my future. I don’t have any definite goals or plans for my career, and I don’t know how to create these plans or put them into action. I chose to read this pattern because it seemed like it might help me figure out a plan for myself. After reading the pattern, I at least think it provides some useful advice. I like that the pattern emphasizes the importance of achievable steps and advises against high-level goals. This makes me think differently about my lack of long-term goals, as I now understand that it is easier to succeed by planning short-term steps. Additionally, the pattern helped me realize the importance of following my own plan instead of one set by my employer. I have had miserable jobs in the past which I felt trapped in due to a sense of obligation towards my employer, but reading the pattern pattern assured me that I do not have this obligation.

One problem I had with this pattern, which also applies to the other patterns I read, is that it assumes the reader is already employed as a developer. For this reason, the pattern doesn’t quite provide the help with actually creating goals that I was hoping for. Despite this, I think the pattern gives a crucial piece of advice in the second paragraph, where it emphasizes the importance of taking a first step. Even without a clear plan, taking a step is crucial for building momentum that can lead to success. Despite not having clear goals for my future, I already know I want to work on regaining my passion for programming in the short-term. After finishing college, I should focus on pushing myself to take this step. Hopefully, I will develop the motivation to keep programming and eventually be able to draw a map for myself to follow.

From the blog CS@Worcester – Computer Science with Kyle Q by kylequad and used with permission of the author. All other rights reserved by the author.