Taylor's Blog

Atypical ramblings

Some videos about release engineering

These following are two fantastic videos I encountered that really help put release engineering into perspective. The first is from a presentation given by Martin Fowler, one of the co-writers of the Agile Manifesto which laid out the principles of agile design and helped kick-start a whole movement that reshaped the software development process. If you have ever encountered the terms scrum, kanban, continuous integration, stand-ups, sprints, or stories, then you’ve encountered a little bit of what he helped to develop.

The video is titled Continuous Delivery and was part of a series of talks Fowler gave titled Software Development in the 21st century at the 2014 XConf conference. You can find the video here.

The second video is from the 2014 2nd International Workshop on Release Engineering keynote speech given by Chuck Rossi, the Engineering Director of Release Engineering at Facebook. He talks about just how important Release Engineering is and of the massive scale of what they need to do at Facebook:

I Made It

This post has been a long time coming. I finally made it. I am currently siting at my new desk in Weston, Massachusetts where I now hold the title of Associate Release Engineer for Monster Worldwide, Inc. Here’s a quick breakdown of the events that transpired:

2/18/2016 – I applied to a Software Engineering Internship position at Monster through their website.

3/3/2016 – I received an email back asking me to come in for an interview on the 15th.

3/15/2016 – I went in for my interview. A number of potential interns were there (over 20 were interviewed in total). We received a brief tour and introduction and then met with the teams. I discussed my abilities and experience and why I would be good for the position. I left feeling good and wrote thank you emails soon after.

3/17/2016 – I give BCNC my three weeks notice. The workload combined with my schoolwork is too much. I needed to leave so I could focus on developing myself for a new career.

3/28/2016 – I receive an email back telling me that I didn’t get the internship, but that there was another manager that might be interested in my skills. Talent acquisition and I exchange some emails and schedule a phone interview.

4/1/2016 – I have my first phone interview with talent acquisition and the manager. More emails are exchanged. I’m asked to come in for an interview.

4/7/2016 – I have my last day of work at BCNC. It’s a somber affair. Having spent so many years there, longer than any other job, it really is hard to say goodbye.

4/13/2016 – I have my next interview with the manager and and some of the devs and engineers. It goes really well!

4/15/2016 – Talent Acquisition calls me back. They’re offering me a job! With higher pay and better benefits than my previous job! My wife and I promptly freak out. The next few days are a blur of paperwork to get the hiring process finalized. Eventually…

5/2/2016 – I start my new job at Monster.

What a ride. I left my previous job with no anticipation of having a new one. It was by complete luck and the stars aligning to give me this opportunity right at the moment I needed it most. It was also incredibly gracious of Monster to give this opportunity. The position was originally earmarked as a senior position. However, one of the senior devs felt it would be more prudent for the company to hire a beginner and train them into the position. I feel like this is something a lot of companies are not willing to do anymore, and as of such, I am incredibly grateful to them. I love my new job and love finally being in the field. I feel like I have forever been on the outside looking in and it seems so surreal that I am finally here.

There’s a lot to learn. Oh my goodness is there much to learn! Monster was one of the first 1,000 websites ever created and there’s a lot of code that has built up since then! There are many tools I am now working on becoming proficient with, including MSBuild, C#, .NET, CruiseControl.NET, Jenkins, Perforce, Jira, NuGet, Confluence and more. But I’m more than willing to do the work. I’m studying my butt off and learning tons. I really can’t believe I’m here doing what I’m doing. It seems much too… soon? I never thought I could make a career transition this quickly. It just goes to show you that if you want anything bad enough, and you put in the time and effort, you can get it.

In other news, I just finished my finals for my Discrete Structures and Intro to Usability Engineering classes. With all of the changes going on in my life, I really couldn’t devote the time to them that I needed and they deserved. I think I still finished strong though, and I’m looking forward to my Fall semester where I plan on taking Computer Architecture and Assembly Language. Until then, I have the summer to enjoy and my new job to keep me occupied. I really haven’t felt this happy in a long time.

See you around!

A Quote about Programming

I was wondering tonight if programming were an art or a science. While googling this idea, I came upon this quote attributed to Richard Stallman on SlashDot:

“I would describe programming as a craft, which is a kind of art, but not a fine art. Craft means making useful objects with perhaps decorative touches. Fine art means making things purely for their beauty.”

A pointer to a pointer to a pointer to a…

This is a small slice of code adapted form a school project I was working on that I feel really helps explain the concept of pointers with arrays. It’s a 2-D array: an array of pointers, each of which points to an array of ints. It essentially forms a 2×2 grid (but you can make it other sizes too).

//function prototype
void fillMatrix(int** myArray, int size);

//main() function
int main()
{
    const int SIZE = 4;
    int** p_myArray = new int*[2]; //make the initial x-axis which has two slots
    p_myArray[0] = new int[2]; //make the 1st y-axis which has two slots
    p_myArray[1] = new int[2]; //make the 2nd y-axis which has two slots

    //alternatively, you could do it this way (if making a 3x3 grid with SIZE=3):
    /*
    int** p_myArray = new int*[3];                                     
    for (int i = 0; i < 4; i++) //for every x-axis...
    {
        p_myArray[i] = new int[3]; //make a y-axis three slots big                  
    }
    */

    //function call
    fillMatrix(p_myArray, SIZE);
}

//function definition
void fillMatrix(int** myArray, int size)
{
 cout << "Please enter " << size << " integers to fill the array." << endl;
 for (int i = 0; i < (2); i++)
     {
         cin >> myArray[0][i];
     }
}

Just to help visualize it, here is what a 2-D, 5×5 array looks like:

M75kn

Happy New Year!

Wow. It’s the end of 2015. What a ride it has been. I can’t believe that I started programming a year ago. It feels… not so long ago haha. Looking back, I see that I have really grown as a developer. And I guess as a person too. I can’t continue this post without first mentioning the biggest thing to happen in my life. Last week, December 21st, I got married to the most wonderful girl in the world. I really couldn’t have come so far without her never-ending support. I really am blessed. Because she was on a fiance visa, we only did the civil wedding at city hall. A really low-key thing. It was great though – my whole immediate family got to be there. We plan on doing a much grandeur wedding this April/May when her mother comes to visit. How many people get to say they had two wedding celebrations, huh?

Last month I finished my first computer science class – Introduction to Computer Science I. It’s only the first step of my academic journey, but I can’t help comparing this semester to the semester I had ten years ago. Ten years ago I was a freshman in college also enrolled  in my first CS class at the UMass: Dartmouth. I was taking Object Oriented Programming I and I had never felt more in-over-my-head than those few weeks I was in the class. I was thrown right into a Linux environment and expected to do… well pretty much the same stuff I did this semester at OSU. I realize now that at that point in my life, I wasn’t ready for the rigors of pursuing a CS degree. I was naive and immature. In a panic, I switched out of the program – eventually winding up in the history department after a semester of non-major pre-requisite classes. Looking back, I see that switching out was the right thing to do. Had I stayed in that class, I probably would have flunked it. Maybe I would have even flunked out of college. It was a scary time.

But now all that is behind me. I have a bright future ahead of me and I’m feeling exceedingly optimistic. I love the OSU program so far and feel like my knowledge is growing exponentially each day. Second semester starts next Monday. In the meantime, I’m back to learning Python and Flask. I really want to deploy my program onto the web. I’m very excited about it. However, I’ve been away from Python so long that I’ve forgotten a lot of its conventions. While doing some simple programming, I had a devil of a time getting a program to run correctly until I remembered that you can’t use the ++ operator in Python. As Steve says, I was “corrupted by C++”, heh.

Well let’s talk about some new stuff. What have I learned recently?

  • If you put a main.py file and a module file in the same directory and run the main.py file, it’s able to import from the modules without an __init__.py file. However, if the module was in another directory, you would need to add an empty  __init__.py file. This is because the __init__.py file is how Python identifies directories from which you’re allowed to import. The directory of the script you’re running is an exception – you’re always allowed to import from it. (source)
  • When the Python interpreter reads a source file, it executes all of the code found in it. Before executing the code, it will define a few special variables. For example, if the python interpreter is running that module (the source file) as the main program, it sets the special __name__ variable to have a value "__main__". If this file is being imported from another module, __name__ will be set to the module’s name. (source)

Here is a (relatively) simple example of how to import a class, create an object and use a method in that object:

#main.py
from myModule import MyClass

def main():
    instance = MyClass()
    instance.myMethod()

if __name__ == "__main__":
    main()
#myModule.py
class MyClass(object):

    def __init__(self):
        print("Object created!")

    def myMethod(self):
        print("Hello from myClass.myMethod()")

When run, this will be the result:

Object created!
Hello from myClass.myMethod()

Pointers: Round 2

Last Saturday I had my final exam for my CS161 course. I did okay, but I could have done better. I realize now that I really don’t have a handle on how pointers work still, so the goal of this post is to try and help myself understand them a little bit more.
I was watching some videos from The New Boston when I noticed that in the comments section some people were saying that the video had mistakes. It’s a bit disheartening to hear that the people trying to teach you pointers can’t even get it right. I’m going to try and digest what was in the video and what the commentators said. Here’s my synopsis:

Pass-by-reference uses references, not pointers. Pass-by-address uses pointers. Pass-by-reference and pass-by-address are not the same thing. It’s an important distinction because pass-by-reference is handled differently when calling the function.

A pass-by-reference function using references looks like this: passByReference(int &x);

While a pass-by-address function using pointers looks like this: passByAddress(int *x);

The important difference here is that passByReference is used (called) the same way as passByValue:

passByReference(betty)

passByValue(betty)

A passByAddress requires that you specify an address or a pointer as the argument. That is, you need to send a pointer/address:

int myVar = 5; 
int *myPointer = myVar; //Pointer points to address of myVar
passByPointer(myPointer)

or you need to put an ampersand (&) in front of your variable to denote it’s address rather than it’s value:

passByAddress(&myVar)

About the & operator

“&” is for the address of something. But when used when declaring a new variable, it becomes a different thing.

int a;

&a; // address of a

int &a = b; // the “&” now means you’re declaring a reference to “b”.

Of course, when declaring a refence, you must immediately assign it to something. References must always refer to something, they can’t refer to nothing.

So…

int &a; // not valid

int &a = b; // valid

To use it with function, you need to declare the function this way, to accept references:

void function(int &a); // takes a reference to an int

And then you just send any “int” to it:

int a;
function(a);

It looks like we’re sending the value of “a”, but because the function was declared to accept references, not values, you’re actually sending a reference to it.

——

I also found some help from this StackOverflow thread:

void makePointerEqualSomething(int *pInteger)
{
 *pInteger = 7;
}

In the function declaration, * means you are passing a pointer, but in its actual code body * means you are accessing what the pointer is pointing at.

In the function declaration, * means you are passing a pointer, but in its actual code body * means you are accessing what the pointer is pointing at.

& means get the address of something, its exact location in the computers memory, so int &myVariable; in a declaration means the address of an integer or a pointer, while

int *pInteger;
int someData;
pInteger = &someData;

means make the pInteger pointer equal to the address of ‘someData’ – so now pInteger points at someData and can be used to access it when you deference it:

*pInteger = 9000;

You can read that last line as “what is at the memory address pInteger points to is equal to 9000.”

References & Pointers

This week our class has finally encountered pointers. I knew that it would be a challenging subject, so I’m trying to take it slow. There are a couple of questions I have been trying to resolve in my mind since encountering these two concepts. The first one is: what is the point of pointers?

That’s where I discovered this comment on reddit that I feel applies to both pointers and references:

The best metaphor I’ve found for pointers are websites.

You could copy and paste the contents of a website into a document and then send that to someone, or you can send a pointer (the URL) to them.

The benefit of the pointer is if the site gets updated, you both see the changes, whereas if you send a pasted document, they will never see any changes.

If you just use the variable, it’s copying the whole contents of the variable. Whereas if you use a pointer/reference, it’s sending a lot less data and using a lot less memory.

Another difficult questions I’ve been working on answering is what the difference is between pointers and references. For that answer, I went to StackOverflow:

Use reference wherever you can, pointers wherever you must.

Avoid pointers until you can’t.

The reason is that pointers make things harder to follow/read, less safe and far more dangerous manipulations than any other constructs.

So the rule of thumb is to use pointers only if there is no other choice.

I’m sure there is more to it than that, but feel that those cover the basics pretty well. Now for actually learning the syntax. I wrote a little program to help remind myself of the finer points:

 int myInt;
 int *myPointer;
 myPointer = &myInt;
 *myPointer = 5;
 cout << "myPointer points to address " << myPointer << endl; //outputs address
 cout << "The value stored at that address is " << *myPointer << endl; //outputs 5

 //An array name, without brackets and a subscript, actually represents the starting 
 //address of the array. This means that an array name is really a pointer.
 int myArray[] = { 10, 20, 30 };
 cout << *myArray << endl; //outputs 10

 //These two lines do the same thing:
 cout << myArray[1] << endl; //outputs 20
 cout << *(myArray + 1) << endl; //outputs 20

 //This adds 1 to the first value in the array:
 cout << *myArray + 1 << endl; //outputs 11

 int *arrayPoint; //This is a pointer that points to an int (or an array of ints)
 arrayPoint = myArray; //Assign it to an array to point to
 cout << *arrayPoint << endl; //outputs 10
 arrayPoint++;
 cout << *arrayPoint << endl; //outputs 20

I’ll add some more notes for pointers and references later.

College Capers

It’s been two months since I last updated – time to type! I’ve been extremely busy lately. In the middle of September I was in China again visiting my fiancé for a week. We’re very excited because she will finally be joining me in the U.S. on November 5th! It was a very hectic week abroad – mainly spent with her close family and friends and preparing things for her departure. In addition, my first week of college at OSU began while I was abroad. It wasn’t too bad because OSU provided a VPN I could use to get over the firewall during that time.

Also in September I had the hectic process of moving into a new apartment with a close friend from college. It’s definitely a step up from where I was living before and really something I am not embarrassed to bring my fiancé home to. Just last weekend, I finished acquiring all the major furniture needed for the house including  a new couch, mattress and bed. I’m looking forward to just chlling out at home this weekend now that the place is finally furnished in an acceptable manner.

So now I am smack dab in the middle of CS 161 – Introduction to Computer Science. And so far… it’s going great! It’s stressful and demanding for sure, but that’s exactly what I was expecting. I am really glad to be moving forward in a positive direction for my (and my fiancé’s) future. Overall the course hasn’t been too difficult which I attribute to my previous programming experience. From the online forums, I know that there are a few people who are doing worse off than me, so I count myself as lucky.

This first class is focusing heavily on C++ and there have been a few stumbling blocks for sure, but nothing I wasn’t able to work out with a little effort. Some of the more new things to me include:

  • named constants
  • c-strings
  • overflow and underflow
  • output formatting manipulators (setprecision, fixed, showpoint, left/right)
  • cin.ignore()
  • the conditional operator (expression ? expression : expression;)
  • switch statements
  • enumerated data types ( enum Roster { Tom, Sharon, Bill, Teresa, John }; )
  • sentinels and flags
  • function protoytpes
  • static variables
  • reference variables
  • overloading functions
  • stubs and drivers

I have really been learning a lot and at quite a fast paces. I’m managing to keep up but I’d be lying if I said I wasn’t worried about next semester. This semester I’m only taking one class, but next semester I am set up to take two, AND my fiancé will be here. I need to juggle all of this while also working full time. It could get tricky. In any event, I’m hanging in there and it feels good to do so.

Seeing C++

My first class at OSU doesn’t begin for another month, so I have started reading the textbook for my first class in the meantime. It’s CS161 – Introduction to Computer Science I. The textbook is Starting Out with C++: Early Objects. It’s my first time learning C++ and it has been a little more difficult to get started with than, say, Python.

For starters, getting an IDE up and running to compile and run C++ code has is not very straight-forward. Often I read that the recommended starting point for C++ is Visual Studio and it is much different from IDEs I have used in the past. With Python, you can just download the latest version and write and run a .py file using the included IDE. But with VS it’s no so easy. It seems to be that:

  • VS is optimized for huge projects, not single-file programs
  • VS student has a command prompt that you can use to run single-file programs, but you need to optimize it with special flags like cl /EHsc /nologo /W4 myProgram.cpp
  • You can also run a C++ program straight from the command line in Unix, again with special flags like g++ -std=c++14 -Wall -Wextra myProgram.cpp -o myProgram.exe
  • You can write a simple batch script to include those code lines and make it easier to run a C++ file
  • In SublimeText (and possibly Notepad++) you can build and run single cpp files very easily, provided that you manage to set up the command line compiler on Windows.
  • Here is an online C++ compiler you can use if you do not need any 3rd party libraries or disc access
  • Some simpler IDEs might be CodeBlocks, CodeLite, and BloodShed
  • Steve recommends Cywgwin and VIM. He says that if I’m not using Visual Studio on Windows, my best be is to just go on Linux. The only languages that work really well on Windows are Python and C#.
Taylor's Blog © 2015