For the eighth week’s reading, I chose to read the pattern, Confront Your Ignorance. This pattern takes on the problem that you have gaps in your skillset that is needed for the job. These could be tools or techniques that you are already expected to know but you don’t and need a place to begin. The solution to this problem is custom to the person in need, there are many different ways to start. Two ways suggested are trying to start with introductory material or jumping straight into hands on learning. It is mentioned that even if you are doing this in private to learn and apply it in the workspace, there are issues that could arise. One is that you are using work project experience for private projects solely for yourself and not the team. Another would be that the team will not be able to help you, learn with you, or help you along the way. As an apprentice, you should be learning in public where others can see the way you work.

The interesting part of this pattern is about the negative side effects from learning in private. When you work as a team, it is expected that you fail together, learn together, and learn from each other. By working solo and focused on improving your own performance, you are neglecting your team in the process. Another negative would be that you chose to implement a feature or system that has already been created elsewhere. By implementing your own version of it, the other members of your team are now required to learn from you about the system. This is a drawback and should be carefully considered when valuing your company’s resources and teammates workload.

This pattern has caused the way I think about my intended profession because there is a need for balance in terms of solo and team activity. If the workload shifts towards solo, then you aren’t benefiting your community. But if the workload shifts towards the team, then you are over reliant on the team. What I learned is that, you must know how to balance your learning such that everyone is winning in the end.

From the blog CS@Worcester – Progression through Computer Science and Beyond… by Johnny To and used with permission of the author. All other rights reserved by the author.

For this weeks blog post I will be looking into the Breakable Toy pattern. The context behind this pattern is that experience is built upon failure as much as if not more than success. This is something that most people will agree with that you cannot better yourself without failure or knowing your shortcomings. Say for example you are working in an environment that really does not permit failure yet failure is important to learn from your mistakes. This could cause you to play everything safe without being bold causing you to never truly get the most out of your job. By being bold, failing due to new tricks or the boldness can you grow into a better version of yourself when faced with difficult problems. In a way this pattern is very similar to Be the Worst, but that pattern is about finding a team where you can be the worst in order to grow. Breakable Toys is about creating opportunities to learn by going out of your comfort zone and single handedly building complete software projects. Using your favorite tools to build the worlds simplest wiki while still maintaining the highest standards of quality is an example that fits this situation well. The initial version will not be fancy in anyway but a simple user interface that lets you view and edit the plain text files. As the project moves along you can add more features and find new interesting ways to distinguish the project from the other pre existing thousands. Let your professional- interests guide you not the constrains of existing implementations. It does no0t matter what you decide to do in this project but as long as you are experimenting and learning from it you are growing as an individual. Back to the be your worst blog I wrote a few weeks back I completely agree with the breakable toy ideology. This is a very good mentality to have especially for your own growth one I would see myself using yet again.

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

        The “Practice, Practice, Practice” pattern is explained as one of the better ways to develop your skills in new areas and get better with hands-on learning. The book continues by saying that being able to learn skills on your own time gives you multiple benefits that can’t exactly be emulated in a work environment. In a work environment, you constantly feel the pressure of learning new skills and learning them quickly while practicing by yourself allows you to control the rate at which you want to comfortably learn. The main idea of this pattern is to have a stress-free environment for you to experiment and eventually learn in. The idea of integrating feedback loops should also be in the back of your mind since it could prove useful here. It is possible to develop bad habits as you practice so making sure that someone can give feedback on your practice afterwards is also crucial. This allows a better learning experience in the long run by quickly correcting any habits that form rather than letting them sit with you for an extended period of time.

            I found this pattern to be important and useful as a reminder to make sure that I keep practicing. It outlined the positives of practicing code and how to set a personal pace for learning compared to a work environment. I found that when the book talked about the fast pace of work being different from learning at home, it resonated with me much more. I want to incorporate this pacing technique for personal learning more to find out how it can affect my overview on a subject. I predict that it will allow me to continue learning without getting too burned out since I would be able to control the pace at which I want to digest information. This can be helpful because there are some days where I don’t feel like working a lot which allows me to control the learning load compared to days where I want to learn a lot. I agree with this pattern for that very reason, to be able to personally create my own time schedule as long as I continue practicing at a continuous rate. Practice can only make my knowledge base greater and it allows me to experiment with ideas that I wouldn’t be able to in a work environment at my own pace.

From the blog CS@Worcester – Student To Scholar by kumarcomputerscience and used with permission of the author. All other rights reserved by the author.

Agile Testing

For this week’s blog post I will be discussing Agile Testing, describing what it is, its principles and more. First of Agile Testing is a software testing process that follows agile software development-based principles. Essentially agile testing is a continuous process rather than being sequential. The testing begins at the start of a project becoming integrated into the testing and development of the entire project. Now there is a testing like this called waterfall testing where waterfall testing is a bit more structured and detailed while agile testing is more minimal. From the blog I list down below there is a large compare between the two that I will save for the viewer to visit as it covered in fall better detail there than what I could write here.

Main Principles of Agile Testing

The main principles that come out of agile testing are as follows. Testing is continuous ensuring the continuous progress of a project with Continuous feedback that provides an ongoing basis for what your project’s requirements are going to need. Tests are performed by the whole team, the developers and the business analysts of a project also test the application instead of just the test team. The decrease in time of feedback response, this is essentially due to the continuous testing allowing a better understanding of what is happening allowing for a better response rate. Simplified and clean code, Less documentation, and test driven  are all key principles that arise from the continuous testing as listed above several times, allowing for all of this to be done in a much cleaner fashion.

Advantages of Agile Testing

The benefits from agile testing are simple as it all comes from the continuous model it follows. First and for most it saves time and money, due the testing taking place right from the beginning and not at the end. Less documentation is needed, along with it being very flexible and adaptable to changes throughout its progress. Regular feedback is provided once again due to the continuous model.

In conclusion the agile testing not only facilitates early detection of bugs/defects but reduces time spent on fixing them. This model of testing can yield a much better-quality product/project due to its constant testing processes. The article written here is very informative about agile testing, I just only wish that some of the ideas were fleshed out a little more with perhaps a few examples showing how it works in reality.

https://reqtest.com/testing-blog/agile-testing-principles-methods-advantages/

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

For this week’s blog post I will be discussing the decorator design pattern discussed in Derek Banas’ Design Pattern Video Tutorial’s found on YouTube. Here you can find pretty much any design pattern you are interested in where he will discuss it in a video usually under 15 minutes.

You use this design pattern when you want the capabilities of inheritance with subclasses but know you need to add functionally at run time. You can modify an object dynamically because of this. Decorator Design is more flexible than inheritance. Simplifies code because you add the functionality using many simple classes, causing you to be allowed to extend with new code. The example he uses explaining the pattern is a great one. You have a pizza and you want to be able to put multiple toppings on top and such. He shows how messy it can be with simple subclasses and an inheritance-based system. Then he shows how to do it in the design pattern showing how useful it can be in situations like this. Essentially you make a pizza interface, with a concrete class being a plain pizza where you can modify its toppings. Then you have a Topping Decorator abstract class where the bases for the toppings will go, followed by a topping class for each topping you’d like to have. Next, he runs through what this would like in code. He writes the code out improving upon the previous inheritance-based code he had down before. What he writes is a much cleaner and simpler version of what he set out to do which is made possible by the decorator design pattern.

This entire YouTube channel, specifically this playlist of his is perfect for learning any of the design patterns we may or may not discuss in class or you want to learn on your own. Like I said above he explains everything in detail in a good pace where almost anyone could understand what is happening in the video. Along with the examples he shows and writes in real time, I recommend this channel/playlist to anyone who is interested in learning design patterns.

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

Source: https://www.softwaretestinghelp.com/automation-testing-tutorial-1/

In this week’s reading was about a test automation tutorial. It defined test automation as a technique to test and compare the actual outcome with expected outcome. Mainly used for automating repetitive tasks which are difficult to perform manually. Test automation allows testers to achieve consistent accuracy and steps towards testing. This in return would reduce overall time towards testing the same thing over and over. As the tests should not be obsolete, it would allow new tests to be added on top of the current scripts when a product evolves. They also suggest that these tests should be planned so that maintenance will be minimal, otherwise time will be wasted when fixing automation scripts. The benefits are huge but there will be challenges, risks, and other obstacles. Such as knowing when not to automate and turn to manual testing which would allow a more analytical approach towards certain situations. Which is directly related to the perception that if no bugs are introduced if automation scripts are running smoothly. It is concluded that test automation is only right for certain types of tests.

I found this tutorial to be incredibly helpful as it provided real-life situations as examples for many of the topics covered. It is effective at making the user see the reality behind test automation, through the five W’s – who, what, when, where, and why – even not stated explicitly. I can conclude that I took test automation for granted as I assumed that all tests would be automated regardless. That way of thinking is a wrong step for a tester to make, as not all bugs can be discovered through pre-defined tests in static test cases. Manual testing is necessary to be able to nudge bugs to appear through manual intervention as it pushes the limits of the product. Overall, the main take away for myself would be the planning phase of test automation. By splitting different tests into different groups, we can easily set a path for testing in an ordered way. For example, it would be best to do tests for basic functionality then integration before testing certain features and functionalities. It would logically be more difficult to solve complex bugs before smaller bugs. It goes to show that test automation is not as easy as it looks.

From the blog CS@Worcester – Progression through Computer Science and Beyond… by Johnny To and used with permission of the author. All other rights reserved by the author.

This tutorial What is REST API Design? on mulesoft.com is a beginner friendly description of how REST API’s operate. The first section of the tutorial focuses on defining RESTful API’s and how they are typically used. However, the majority of the post describes the five key criteria that turns a regular API into a RESTful one.

What makes Representational State Transfer (REST) API’s different than other API’s is adherence to predetermined protocols. Like how IP and TCP are a set of guidelines that allow information to be shared over the internet, REST API’s have a set of five criteria that every developer designing this system must follow.

The first criteria is the API must be a client-server architecture. This rule says that the client end and the server end of the system should be separate and have no dependencies. Any changes to the database or the program calling the API should not effect the other part of the system.

Second, the API must be stateless, which means that all calls on the API should contain all the data the server needs to fulfill the request. The client end does not need to store data in the server itself.

Third, when the REST API’s respond to requests, data that is sent to the client should be stored in cache memory, which is faster and reduces stress on the server end.

Fourth, there should be a uniform interface handling communication between the client and server end. Usually, this is done by using HTTP and URL’s. This is a crucial function of the REST API, as there needs to be a common lifeline between the requests and responses.

Finally, the API should be a layered system. This constraint ensures that the program will be divided into layers, each focusing on a particular responsibility and handling communication to the next level above/below. This gives a certain level of security and flexibility between layers of the system.

This tutorial definitely helped my understanding of REST API’s, as the author went into some detail describing each of them and what role each constraint plays in achieving the goal of RESTful API’s.

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

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