Category Archives: Week8

Sustainable Motivations

For this week, I am going over the Sustainable Motivations pattern! To me, this pattern was both a bit confusing and also impactful at first! I felt that I had an idea of the type of guidance it was trying to show me, but at the same time, I felt that parts of it were a bit conflicting or irrelevant. That is, until I went ahead and tried it out in practice.

Specifically, the pattern calls for writing down fifteen (15) things that motivate you, then write another five (5) after waiting for a bit. Then, compare how different the two list are and what percentage of them are composed of external sources of motivation. Then, from both list, take the final five (5) that most motivate you.

From what I understood, it was trying to get you to differentiate between sources of motivation that are from your own self vs motivation that is pushed on by others, and also, ensure that the reason you continue to pursue programming is healthy. As it says right in the name, it is important to have sustainable motivations.

For example, if someone has, an ‘unsustainable’ motivation, they will be more prone to burn out, or even quit, but if someone has sustainable motivations, then even if they encounter difficulties in their work, project, or anything similar, they will continue to keep moving forward. This is obviously crucial, but the one part that I found a bit confusing at first was that I didn’t realize that external sources of motivation can also be fine as well as internal. I had assumed that all external sources were bad, but after writing down my list, I realized that, well, it’s okay to be motivated by those around you. It would be important to always have self confidence in yourself and it is important to continue coding because it is fun, or exciting, but there is no reason that you cannot have a healthy motivation because you want to follow in so and so’s footsteps because you respect them. From what I gathered, the pattern is not about internalization, but about a healthy balance of motivations to fight against burn out and stagnation!

From the blog CS@Worcester – Bored Coding by iisbor and used with permission of the author. All other rights reserved by the author.

Refactoring code!

For this week, I considered a topic that I was more familiar with instead of something completely new, but all the same, I still looked into it further since there were a few things that I had no idea about!

Before our more recent classes where we learned about the Singleton and Simple Factory pattern, I knew about the concepts of refactoring, but in a different light. Rather than using these patterns and methods to make my code more efficient through a pattern of sorts, I consider refactoring as something more akin to making my code more readable and more efficient by breaking down useless portions of code. This isn’t exactly wrong, but it’s not completely right either!

Mainly, because though these approaches were important, they could be done even better! I main thing that I was missing in my own refactoring was obviously the design smells that we have recently went over now. Intuitively, I understood a few of the smells already, but now that I have a better grasp of many of them, it is clear that my older refactoring efforts were missing plenty of things!

For example, I used to clean up code and make it easier to understand by breaking them into chunks, which is good, but at the same time, I would also condense other areas since they seemed to ‘fit.’ It is clear now that I should NOT do that, but you live and you learn!

I think that the biggest resource that I found so far, is this website! Though it is basic and even a bit barebones, it gives a pretty good introduction to refactoring. It makes sure to consider things such as cleaning up dirty code from inexperience, a refactoring process, the design/code smells, and techniques to refactor as well as show off a few different design patterns!

One thing that might be helpful is that the website contains many different images to help break concepts down and even code examples! I know for me, it helps tremendously when I can look at some code and see exactly what is happening! Though I do understand the concepts a lot of the time, I find that I learn things a lot more quickly if I can look at the source and break things down myself! The website even has plenty of different coding languages too, so if say, Java isn’t your best, you can look at the different patterns in C#, Python, etc!

Overall though, I think that learning about a more refined structure to refactor code and implement these various design patterns will help me tremendously! I know that there have been times where I have gone to look at my old code and I’m sitting there lost, confused, and asking “Who did that!” Hopefully, with this in mind, I’ll have a better understanding of how to proceed with my older code past and future!

From the blog CS@Worcester – Bored Coding by iisbor and used with permission of the author. All other rights reserved by the author.

“Encapsulate what varies”

When asked the question “Which object-oriented design principle do you think is most important?” a Software Architect named Nicholas Cloud answered, “Encapsulate what varies”. I must say, I couldn’t agree more. In his blog, DeveolpIntelligence, Nicholas writes about his desire to constantly look for ways to utilize this principle to make writing expressive and maintainable code easier. He gives a lot of great examples and breaks them down, explaining each way they can be changed and why that change makes the code better.

Encapsulation means to bundle data with methods that operate on that data, or to restrict the direct access to some of an objects components. There has been some debate between programming language researches on which meaning they prefer to use. The Gang of Four suggests that we consider what should be variable in our designs. This approach is the opposite of focusing on the cause of redesign. Many design patterns use encapsulation to create layers between objects, making it easy to change things on different sides of the layers without negatively affecting the other side. There are so many advantages of encapsulation, from data hiding, to reusability, to making testing your code easier.

As one of the fundamentals of OOP, it is arguably one of the most important due to the number of advantages it brings. I found all the information I obtained from a few different blog posts and articles, all of which had almost the exact same information. Having read just the definition, understanding the true essence of encapsulation was difficult, but the code examples I found were extremely helpful and made things clearer. I thought the manner in which the information was presented was easy to follow and the use of real-life examples and comparisons kept me interested enough to stay focused on the subject. Below is an example I found easy to understand;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16		 class Person {
String name;
int age;

 void talk() {
}
 
void think() {
}
 
void work() {
}
 
void play() {
}
}
The common characteristics and behaviors of a person are packaged into a single unit: the Personclass. The Person class is an encapsulation unit and the Person object exposes its attributes and behaviors to the outside world:
1
2
3		 Person you = new Person();
you.name = "John";
you.work();
Here, encapsulation hides implementation details of the Person class from other objects. Likewise, creating an interface is also the process of encapsulation:
1
2
3
4
5		 interface Human {
void eat();
void talk();
void think();
}
This interface groups the essential behaviors of human-being in a single unit.

The rest of the examples can be found at https://www.codejava.net/java-core/the-java-language/what-is-encapsulation-in-java-the-what-why-and-how.

I enjoyed learning about this principle and I feel more confident going forth in this field knowing yet another way to make writing code neater, more maintainable, flexible and easier to read.

Knowledge obtained for this blog post:
https://www.informit.com/articles/article.aspx?p=167890&seqNum=4
https://www.developintelligence.com/blog/2013/04/encapsulate-what-varies/
https://levelup.gitconnected.com/object-oriented-design-principles-bb6daf98b185
https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)
https://www.geeksforgeeks.org/encapsulation-in-java/

From the blog cs@worcester – Coding_Kitchen by jsimolaris and used with permission of the author. All other rights reserved by the author.

Blog 8: Angular 2 Response

Hello readers, today I’m doing my response blog on a post from AshuTomar who wrote a very nice blog related to computer science and something that is actually being talked about in my computer science class right now.

The blog starts by talking about typescript, the writer says it is type safe which means it can generate errors at compile time only. It is also purely object oriented an extends object oriented javascript. Typescript also allows to write class, interface and module-statements just like in Java and lastly typescript can transpile to any version of javascript code.

Next the writer talks about the speed and performance of Angular 2 and that it supports lazy loading which means you don’t need to load the complete app at once but modules can be loaded dynamically whenever there is a requirement. Angular 2 also supports AOT compilation which allows you to compile your code ahead of time.

Skipping the uses of the valid HTML, DOM section, the writer talks about the modular design of Angular 2 and how it is easier for Java based programmers to learn a new Javascript framework. Lastly though in the blog the writer shows code how to use the bootstrapping application and talks about and shows dependency injection enhanced.

The reason I chose this blog was because it is very familiar to what we are talking about in my software class in college right now. We are trying to do typescript in webstorm for our duck simulator program that we had to write in different strategy patterns. Getting back to Angular 2 and typescript, this blog explained a little about typescript and what the writer learned from Angular 2 and how it works and what it can do. I’m not an expert on Angular yet, just learned it was a thing so getting any information from anywhere right now is always good to improve my skills. The writer says Angular 2 allows people the ability to make a single page application in a perfect viable way. Reading that makes me really want to get into Angular and learn it because going to a work place and applying to a job, if you can make them a webpage or do any computer science things that involve creating applications, it makes you more wanted than if you didn’t. That is given that if you have more impressive details on your application then you will be more wanted by a job, well with this skill in angular you could also do some freelance work, make webpages or applications for different companies for a side job, a lot of people could make a lot of money just by doing that, so I’m not shying away from learning angular and type script. In conclusion, Angular and typescript are very important for a computer scientist future, also this blog is a good read, gives some details about angular 2 and how it works. Thank you for reading my blog this week, come back next week for some more programming talk with me.

Source: https://blog.knoldus.com/2017/06/14/when-i-took-angular-2-to-build-my-application/

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