DevOps part 5, Reflection

--Originally published at Fernando Partida's Blog

Finally, this is the last DevOps assignment, is what i thought upon reading what the assignment entailed. I’ve been working learning and changing many things i knew about regular development throughout the progress of doing these assignments.

I really already knew all of the things that were assigned with these practices, but I never did actually use them at all. Well, the previous was until I started the assignments. I learned the actual importance of automation, not only for testing, but also for mundane tasks such as checking changes on a git/GitHub repository.

With the realization of the use of automation, tasks that seemed easy but time consuming now were completely gone, as they could be done automatically without any need to lose time over them.

I gained appreciation for so many things whilst working with the DevOps assignments, and the overall values of team working in not only work but everyday tasks.

DevOps part 2, Linux Server Setup (Individual)

--Originally published at Fernando Partida's Blog

For part 2 of DevOps we were assigned to install a linux distribution, run a server, and use crontab to schedule execution.

The linux distribution that i chose to use is that of Ubuntu 18.10 because i already had it installed as a virtual machine.

DevOps part 2, Linux Server Setup (Individual)

For setting up the server I installed nodejs with the following command:

sudo apt install nodejs

With nodejs installed, a script for running the server was created at a folder designated for testing. The script written was the following:

const http = require("http");
const hostname = "";
const port = 8080;

const server = http.createServer((req, res) = >{
        res.statusCode = 200;
        res.setHeader("Content-Type", "text/plain");
        res.end("Server testn");
server.listen(port, hostname, () = > {
        console.log("El servidor esta corriendo");

For testing the following bash command can be run:

node test_server.js

This will show us the following screen:

DevOps part 2, Linux Server Setup (Individual)

After that it was just question of sheduling it to run. For now i set it for running 24/7, 365 for testing with the following code:

First to enter crontab the following command was run:

sudo crontab -e

Then the script used was the following

# Edit this file to introduce tasks to be run by cron.                          
# Each task to run has to be defined through a single line                      
# indicating with different fields when the task will be run                    
# and what command to run for the task                                          
# To define the time you can provide concrete values for                        
# minute (m), hour (h), day of month (dom), month (mon),                        
# and day of week (dow) or use '*' in these fields (for 'any').#                
# Notice that tasks will be started based on the cron's system                  
# daemon's notion of time and timezones.                                        
# Output of the crontab jobs (including errors) is sent through                 
# email to the user the crontab file belongs to (unless redirected).            
# For example, you can run a backup of all your user accounts                   
# at 5 a.m every week with:                                                     
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/                               
# For more information see the manual pages of crontab(5) and cron(8)           
# m h  dom mon dow   command                                                    
* * * * * /usr/bin/node /home/ferpart/Documents/Code/DevOps/test_server.js

Asterisks were used so that it runns all the time.

Intro to DevOps (Individual plus peer review)

--Originally published at Fernando Partida's Blog

DevOps as its name states is short for “Development Operations”. This is a term that started from the combination of the agile operations and that which is the collaboration between the development and operation staff on all stages of the development cycle.

In general its described as stated before “it is a collaboration of the developer and operations”. The following are the generally known levels of a DevOps structure.

  • DevOps Values: These are fundamentally the same as those seen within the agile methodology. Just with slight tweaks focused on the service delivered to the customer.
  • DevOps Principles: One of the most commonly cited principles is that of “Infrastructure as code” otherwise, no other general principles have been agreed collectively upon.
  • DevOps Methods: Methods for implementation are generally the same as with other methodologies. these could be “scrum”, “kanban”, etc…
  • DevOps Practices: The most important practices is that of continuous integration and continuous development.
  • DevOps Tools: Tools that could be used are vast, but these are some examples; “configuration management”, “orchestration”, “monitoring”, “virtualization and containerization”, etc…

In general we can then understand that even though DevOps is a very good, versatile and easy to use tool, It is not very easily defined.


Secret Life of Bugs (Individual)

--Originally published at Fernando Partida's Blog

I enjoyed reading the secret life of bugs paper. Even though it was a bit on the long side it had analogies that made everything easier to understand. It gave the reader a way to understand and analyze where it is that software “bugs” come from. The paper also gave a overview of how it is that bugs are commonly found, observed, and finally corrected.

Unit Tests (Individual)

--Originally published at Fernando Partida's Blog

For unit testing i decided to go with Eclipses’ included Junit 5 for testing. The library is now added in my project, and it can be used in the case of the implementation i used by importing the Junit.assert.asserequals function to check if a message is displayed correctly.

The following is a list about how to go on with writing on junit 5

My github repository that’ll be used for the class is the following aswell:

Course Review

--Originally published at Hell Yeah

I am currently in the last few hours before the end of the Object-Oriented Programming course, taught by Ken Bauer, with whom I happen to share birthday.

This course was made in such a way that I never saw before. The learning was left almost entirely to us, Ken was more of a guide than a teacher, and I think that was a great way to structure it.

In terms of learning, I went in with little to no knowledge of Java. Object-Oriented Programming in general was an area almost completely unknown to me. With the problems that Ken “assigned” and a few on my own, I was able to learn more about how Java works and why OOP is often used instead of Imperative Programming. Not all of it was practice, the videos that we watched offered interesting perspectives on the theorical side of OOP, along with the opinions of people far above us in knowledge of this topic.

I also learned to use a little of Eclipse, a tool that is used a lot in Java programming. It is, as Ken said at the beginning of the course, a Titan of a program. It has a lot of things that I have no idea what they do or why they are there, but the things I learned to use, I found that were extremely complex but not unnecesarily. What it does, it does not do in a half-assed way, but it can be overwhelming at times.

Also, Github. I have had my Github account for ~2 years, not knowing what it was. I saw on /r/learnprogramming again and again that having a Github account is essential in this line of work, but I never really understood why. Now, I still have a lot to learn and understand about it, hell, I can’t use the terminal commands for git without a guide open in another window, but I know why it is important and what it can do. Github is really the best way to store public code and to manage big projects on a team. It also serves as a kinda-portfolio that gives a testimony of what you know and what you’ve done before.

Talking about the structure of the class, it was a bit “Laissez-faire”. Ken just guided us in the direction we should be going and helped us when we had trouble, but this class did not hold our hand. We were expected to learn on our own and to do our own research about the challenges we faced. I really liked this and I would chose it over the traditional way anytime.


Course Review

Final Exam

--Originally published at oscarlopez95blog

What is an object?

Something that has state and behavior, state can be things to describe the object. (Color, shape, weight, etc.) And behavior is what the object does (Running, talking, walking, etc.)

What is an attribute?
Attributes are the state of the objects, are things who will describe and make your object. If you had a cat object, your attributes would be its size, weight, color, name, etc.

What is a method?
Methods are the behavior of the object, they tell the objects what to do and how to do it. For example if you had a cat object, then the methods would be Walking, meowing, eating, etc.

What is abstraction?
Abstraction in object oriented programming is basically giving information on what the object does, but not how it does it.
Abstract classes don’t need to have abstract methods, but if a class has 1 or more abstract methods, then it needs to be declared as an abstract class.
To use an abstract class you don’t instantiate it, you inherit it from another class, and you need to provide implementation to all the abstract methods it has.

What is encapsulation?
Is wrapping the data and the code that uses said data (methods) together. When you encapsulate a class, its variables will be hidden from other classes and can only be accessed through methods of their current class. To achieve encapsulation you must declare the variables as private and provide public setter and getter methods to modify and view the variables.

What are “has-a” and “is-a” relationships?
“Has-a” relationship is basically when you describe an object, for example a Cat has 4 legs, a name, color, size and weight.

Meanwhile, a “is-a” relationship is when you categorize something, for example a cat is a mammal. You have to realize this only goes one way, for example, every cat is a mammal, but not every mammal is a cat.

What are the mechanics for class description (coding) in the JavaProgramming Language?
For class description in Java we use comments, we use them to make our code understandable and easy to debug, to write a comment you just do this:
/** This is a comment */

What are visibility modifiers, their purpose and use in practice?
There are basically 4 visibility and access modifiers in Java:

The first one, the default one doesn’t use any keyword. And what it does is a variable or method declared without any modifier is only available to classes in the same package.

Private is the most restrictive, it makes variables and methods only available to the class they are declared on, classes and interfaces can’t be private.

Public is the most open one, a variable or method can be accessed by any other class. But if the class we are trying to access is in a different package, it needs to be imported.

Protected basically allows any subclasses to access the variables and methods in a superclass.

What are inheritance and polymorphism? (Specification and implementation)
Inheritance is the process where one class acquires the properties (methods and fields) of another. The information is managed in hierarchical order.
The class which inherits the properties of other is known as subclass, and the class whose properties are inherited is known as superclass. It uses the “extends” keyword.

class Mammal{


class Cat extends Mammal{


Polymorphism is the ability of an object to take many forms, the most common use is when a parent class reference is used to refer to a child class object.
Any object that can pass more then one “is-a” relationship is considered polymorphic.

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

By this logic, Deer is-a animal, vegetarian, deer and object.

What is delegation?
Inheritence uses the java compiler’s type system to implicitly include code from elsewhere, with delegation you explicitly implement the callout.

Inheritance is limited to a single parent class (and ancestors) but it can sometimes be non-obvious where your code is going; delegation is less elegant, but you can bring in functionality from multiple other classes and the flow is clearly visible.

What are CRC cards and how do we use them?
CRC cards are usually created from index cards. Members of a brainstorming session will write up one CRC card for each relevant class/object of their design. The card is partitioned into three areas:

On top of the card, the class name
On the left, the responsibilities of the class
On the right, collaborators (other classes) with which this class interacts to fulfill its responsibilities

Using a small card keeps the complexity of the design at a minimum. It focuses designers on the essentials of the class and prevents them from getting into its details and implementation at a time when such detail is probably counter-productive. It also discourages giving the class too many responsibilities. Because the cards are portable, they can easily be laid out on a table and re-arranged while discussing a design.

What are overloading and overwriting? How do we implement those in Java?
Method Overloading is a feature that allows a class to have two or more methods having same name, if their argument lists are different. To overload, you have two or more methods with the same name, but different arguments.

The benefit of overwriting is: ability to define a behaviour that’s specific to the subclass type which means a subclass can implement a parent class method, but with different arguments. To overwrite, you re-write a method from the super class, with different arguments.

What is the metaobject protocol?

The essence of a Metaobject Protocol is simple: every aspect of a program’s mapping down onto the lower level substrate (i.e. its compilation and runtime support) is controlled by some object or set of objects following a well-defined protocol. These objects are called metaobjects, because they are about the mapping of the program, rather than objects in the program’s primary subject domain. Client programmers can replace one or more of these objects with specialized ones to affect specific aspects of the implementation of specific parts of their program.

What do you feel are the benefits to object-oriented programming?
Code Reuse and Recycling: Objects created for Object Oriented Programs can easily be reused in other programs.

Encapsulation (part 1): Once an Object is created, knowledge of its implementation is not necessary for its use. In older programs, coders needed understand the details of a piece of code before using it (in this or another program).

Encapsulation (part 2): Objects have the ability to hide certain parts of themselves from programmers. This prevents programmers from tampering with values they shouldn’t. Additionally, the object controls how one interacts with it, preventing other kinds of errors. For example, a programmer (or another program) cannot set the width of a window to -400.

Design Benefits: Large programs are very difficult to write. Object Oriented Programs force designers to go through an extensive planning phase, which makes for better designs with less flaws. In addition, once a program reaches a certain size, Object Oriented Programs are actually easier to program than non-Object Oriented ones.

Why do you think your change to object-oriented programming is difficult or what makes it difficult for the standard student?
I think it’s difficult to start because it requires more planning than other ways to program. To create an object-oriented program you need to design it very well, and even though it gets easier as the program gets more complex, the beginning of the program is hard, and by consequence, the learning curve for object-oriented programming tends to be harder at the start.


Final Exam


--Originally published at Alan TC201

The last version of my project is finished, my parther and I made some video games in Java. Dafne did a puzzle, I did a pong.

The pong was made following diferent totorials and I borrow some of the most dificult code, in this case the dificulty, and the puyisics of the ball.

The resourses I use to made this pong was very elaborate, but the principal was the youtube channel Jaryt Bustard. Watching this video was the perfect way to started program my project, and in the end mine looked very similar.

You could say that my ping was a variation between my knowlage and all this different pages. It was difficult to understand how the pyhisics of the ball was going to be but with all the information I found I knew that I had to use the angles of the ball and throw it back in its reverse angle.

The best part of this project was the libertie, I could do what I wanted and I did this game because my father used to play it when he was a child and now he could remember those time with this game.

Here I am going to left the blog of my parther that did the puzzle.


Course Review

--Originally published at oscarlopez95blog

This is my Course Review for my Object oriented programming class with Ken. First of all, my overall opinion on the course is that it is something really new, and the fact that Ken focuses a lot on us learning the concepts helps a lot with the learning curve of the topics. Also, I believe it’s better to learn Object oriented programming in general and then focus on a language that we need, instead of just learning Java por example.


What I think about the topics

The class is about Object oriented programming, and we’ve seen many topics, from objects to polymorphism and delegation. But honestly I think there should be a more interactive way to learn about those topics rather than just reading about them and trying to implement them from nothing.

Sometimes students who are completely new to object oriented programming can get lost because there are so many new things and they’re really different from what you’ve seen before that it just takes time and practice to fully understand them.

What I think about #AbolishGrading

I think this idea is pretty neat, it gives more freedom to the students and prepare us for real life situations. As an engineer you’ll never go to work and your boss will tell you “I need you to write a code that does X thing, but you can’t look anywhere to help yourself”, and after you’re done something like “Oh that’s good, but not great, 83” That’s just not real.

We as engineer students need to realize that a work or a project is about us working as hard as we can and fulfilling both our own and our teacher’s expectations about it.

The grading system doesn’t reward knowledge or how much have you learned, that’s why students cheat, because all they care about is a grade which practically means nothing if they haven’t learned anything.

What I think about Ken

This is the second class that I’ve had with Ken in my degree and I can honestly say he’s one of the best teachers I’ve had in my life. His ideas are new and fresh and he’s not afraid to do and say what he thinks is right for us. He’s not the typical teacher who just grades book summaries and stands up in front of the class room reading a powerpoint presentation, and we need more teachers like him.

Ken, keep up the work like always, don’t let some students too used to the old school system or other teachers thinking you’re crazy change your mind about what’s the best way to facilitate knowledge. Because we both know it’s not about “teaching” is about being a facilitator for students who actually want to learn and become better.

Course Review