Tuesday, April 15, 2014

Chapter 7

This week we were assigned exercises from Chapter 7 in our text, Software Development.

7.1 Not all the tables in RMH Homebase satisfy all six database normalization criteria. For example, dbDates doesn't satisfy either criterion 5 or criterion 6. Give another example of how a RMH Homebase table violations normalization criteria 5. Give another example of how a table violates criterion 6. Explain why either of these anomalies can cause a problem - create more programming work or introduce an error - when updating one of these tables.

What are the six database normalization criteria?

  1. The rows can be rearranged without changing the meaning of the table.
  2. The columns can be rearranged without changing the meaning of the table.
  3. No two rows of a table are identical.  This is often accomplished by defining one column whose values are mutually unique.  This column is known as the table's primary key.
  4. No row has any hidden components, such as an object id or a timestamp.
  5. Every entry in the table has exactly one value of the appropriate type.
  6. No attribute in the table is redundant with the primary key.

The persons field of dbSchedule violates criterion 5 by allowing multiple values to be inserted.  When you try to query an entry with multiple values, this creates more complexity than is needed and can have unwanted side effects.  It is better to keep things as straightforward, organized, and simple as possible.

The id field of dbPersons violates criterion 6.  This field combines the first_name and phone1 fields creating redundancy and causing the primary key to be non-unique.  If, for example, a father and son (John-senior and John-junior) who not only share the same first name, but also the same phone number, are entered into this database and a query is run- it would result in two records that would try and use the same id value- what a mess!

7.2 Develop and unit test the functions get_shift_month, get_shift_day, get_shift_year, get_shift_start, and get_shift_end for the dbShifts.php module that are called by the new get_shift_name_from_id function shown in Figure 7.14.

For this exercise, I consulted with my Team FOSSils.

The first step to this exercise was to modify the get_shift_name_from_id function to the following:

function get_shift_name_from_id($id) { 
     $shift_name=date("l, F jS, Y", 
         mktime(0,0,0,get_shift_month($id),get_shift_day($id),
         get_shift_year($id))); 
     $special_cases = array ( 
         "night" => " night shift", "chef" => " guest chef"); 
     if (array_key_exists(substr($id, 9), $special_cases)) 
         $shift_name = $shift_name . $special_cases[substr($id, 9)]; 
     else{ 
         if (strpos($id, "Fam") !== false) 
             $shift_name = $shift_name . " Family Room "; 
         $shift_name = $shift_name . " from "; 
         $st = get_shift_start($id); 
         $et = get_shift_end($id); 
         $st = $st <12 ? $st . "am" : $st - 12 . "pm"; 
         if ($st == "0pm") 
             $st = "12pm"; 
         $et = $et <12 ? $et . "am" : $et - 12 . "pm";
         if ($et == "0pm") $et = "12pm"; 
         $shift_name = $shift_name . $st . " to " . $et; 
     } 
     return $shift_name; 
}

To implement the rest of this exercise, I decided to create some simple getters for the functions to be tested such as:

function get_shift_month($id) {
    return substr($id, 0, 2);
}

We then made up some simple assertion unit tests like the following:

$this->assertTrue(get_shift_month() == "01");
$this->assertTrue(get_shift_day() == "01");
$this->assertTrue(get_shift_year() == "01");

Exercise 7.3 – Design, implement, and unit test the changes to the database modules required by the new feature Item 4: Calendar month views in the "wish list" described in Appendix B.

After having read this question multiple times, consulting Appendix B, AND attempting to modify dbWeeks implementation; I have come to the conclusion that this is an impossible exercise.  I am planning on consulting with my fellow students in class.



Tuesday, April 8, 2014

Chapter 6

This weeks blog revolves around Chapter 6 in our text Software Development.

1) For the Person class, define a new pair of functions to set and retrieve the value of the variables $employer, $contact_person, and $contact_phone in preparation for implementing new features 1 and 9d in RMH Homebase.

First add the variables to the person class:

private $employer;
private $contact_person;
private $contact_phone;

Then we create the getters: 

function get_employer(){
    return $this->employer;
}
function get_contact_person(){
    return $this->contact_person;
}
function get_contact_phone(){
    return $this->contact_phone;
}

Then we create the setters: 

function set_employer(emp){
    $this->employer=$emp;
}
function set_contact_person(cPerson){
    $this->contact_person = $cPerson;
}
function set_contact_phone(cPhone){
    $this->contact_phone = $cPhone;
}

2) Add four new parameters and corresponding assignments to the constructor for the Person class, so that the status, employer, contact person, and contact person's phone are properly initialized. Use the following prototype for your new constructor:

function __construct($f, $1, $a, $c, $s, $z, $p1, $p2, $e, $t, $status, $employer, $contact, $contact_phone, ...)

function __construct($f, $l, $a, $c, $s, $z, $p1, $p2, $e, $t, $stat, $emp, $cPerson, $cPhone, ....)

$this->status = stat;
$this->employer = emp;
$this->contact_person = cPerson;
$this->contact_phone = cPhone;

3) The set_status function defined in this chapter does not check that the $value passed is valid: either active or inactive. Thus whatever $value is passed becomes a Person's status. Suggest a modification of this function that would perform that check. What value should it assign to a Person's status when the $value passed is invalid? Discuss the unit testing implications of your design decision. 

function set_status($value){
   if (strcasecmp($value,"active") == 0){
      $this->status = $value;
   }
   elseif (strcasecmp($value,"inactive") == 0) {
      $this->status = $value;
   }
   else{
      $this->status = NULL;
   }
}

Test $value as the following:
  • empty value
  • "active"
  • "ACTIVE"
  • "inactive"
  • "INACTIVE"
4) Refactor the existing Person class by removing all the mutators that are not called from anywhere in the code base. Be sure to test your changes by rerunning the test suite. 

I attempted to complete this exercise by using CTRL-F to search for any setter methods.  Unfortunately,   I was unable to find any.   I am unsure how to proceed.

Tuesday, April 1, 2014

Meeting Charleston

Team FOSSil decided to attend Tech After 5 on Tuesday of last week along with Diana from the AM class.  Tech after 5 is an event that is held once a month on a Tuesday.  It is an event for tech professionals looking to network in Charleston, SC.  They also have these events in other major cities in the US.  To attend an event you have to Register online, which is completely free, and then simply show up!  Once you are there, you are to sign-in, grab your name tag, grab a drink (which is also FREE), and start networking.  I really liked that they provided extra stickers that let people know why you were there.  All of us FOSSils had stickers that said "Hire me!".  We spent the rest of the evening schmoozing and speaking with different people.  We talked to some people from Benefit Focus and Blackbaud.  Unfortunately, we saw a lot more "Hire me!" stickers and not more "I'm looking to hire" stickers.  There were so many students...even nursing students??  Not exactly sure why.

It was good experience for all of us to learn how to talk to people and how to engage them.  It can be quite nerve wracking to be in a situation like that, so it's definitely important to practice.  Overall, I think our group did great- we handed out some resumes, got some contact info, and bonded more with each other.  It was a good time and something I'll always remember.

Tuesday, March 25, 2014

Reflections on my progress and plans

On Friday Team FOSSils met to discuss the planning of the poster and looked at examples of what an abstract entails.  We discussed what layout and design we want for the poster.  As far as content goes, we are unsure what exactly we want to include on our poster and which bug fixes we wish to highlight.
We spent part of the meeting discussing what the Django colors are (a very productive use of time).  We want to use their color scheme for our poster.  The dispute was ended when Bobby used the eyedropper tool to tell us exactly what shade of orange and green were being used on their website.  I do want to mention that I was indeed on the winning side of this dispute.  #winning

We submitted yet another ticket fix: #22323, but it was not accepted and the ticket was closed by one of the core developers.  We have also been considering #22161, we are planning on speaking with one of the core developers regarding inconsistent return types.  We shall see.

Tomorrow is Tech After 5, my whole group has RSVP'd so we're ready to get in there and network.  My sister will also be joining us and Diana from the 8AM 462 class will also be there, so we should have a nice little group.

For future meetings, we need to lock down the content of our poster and start fine tuning what we wish to include.

This semester has literally flown by.  I will be on a plane destined for SE Asia in approximately 6 weeks.  SIX WEEKS.  What?!?!  I have only bought my ticket there and back, everything else...I'm just gonna wing it.  I'll be "winging it" for SEVEN adventure filled weeks.  I. Cannot. Wait.  And if I do feel like making some extra cash, I have been approved to "work remotely" for my internship.  Maybe this is what my future looks like?  Traveling to exotic places while working remotely?  One can only hope.


Thursday, March 20, 2014

Planning to Meet in Charleston

Team FOSSils has decided to attend Tech After Five on March 25th at Southend Brewery.  I have actually been to two of these before back in 2013 when my sister was networking for a job.  It's a great place to meet people in the tech community PLUS you get a free glass of wine or beer.  We are planning on meeting at Southend to schmooze and network.  Then we plan on having dinner together at the Blind Tiger which has excellent burger specials on Tuesdays...perfect.  I'm looking forward to it.

Tuesday, March 18, 2014

Release early and often

Release early.  Release often.  And listen to your customers.  We read the Cathedral and the Bazaar earlier in the semester and this happens to be one of the "lessons" Raymond learned from various software development experiences.

Releasing early and often gives great feedback between developers and users which means...

You get bug fixes and and new features in customers hands faster and see how customers react to them.  This is very valuable information for the developers who can work with this information to make a better product and ultimately a happier customer.  In turn, a happier customer makes a happier developer!

Releasing early and often is a way of using customers as co-developers (Free testers!).  And according to Linus's Law-``Given enough eyeballs, all bugs are shallow.''  More heads are better than one.

So if you want happier developers, happier customers, and a better product- releasing early and often is key!

Thursday, March 13, 2014

The Doc is in!

We were to read Chapter 8 in our online text which was entitled "Explaining the Code".  It basically stresses the importance of documentation.  My favorite section was 8.5 and it starts like this, and I quote "Documentation has a reputation as being an easy way to begin contributing to a project. This is more true where the new contributor is already experienced or an expert in the material. It is much less likely to be true where the project has not considered how to enable good and easy documentation, or the technical content is very high."  VINDICATION!  We aren't incompetent- it's just hard!  This whole semester Team FOSSils has been trying to contribute documentation fixes to our open source project Django, but to no avail.  And lets be honest- it's been depressing, but this quote somehow makes me sit up a little straighter and not feel like a complete failure.

We were also to read Chapter 6 in our text.  I'm currently taking CSCI-360 and this chapter goes over  all those concepts we are currently learning.

Exercise 8.1.1
We've been looking at a lot of documentation for Django.  They have a VERY detailed link explaining/instructing how to write documentation for them.  As frustrating as it has been trying to write documentation that is up to their standards- at least they are still allowing us to try and contribute and are always readily available when we have questions.

Exercise 8.4
I do not have enough time for this tonight- this will have to be done at a later date.

Tuesday, March 11, 2014

After the break...

Uggggghhhhhh Spring Break is over?!  My parents rented a beach house on Isle of Palms so that the whole family could be together over the break.  What disgusting weather.  Freezing beach walks and huddling inside for warmth were our family spring break activities.  Which means I was probably really productive over break, right?  Nope.  Oh well.

The FOSSils did manage to have a team meeting on Thursday over the break, where we realized that nothing we do will make the Django crew happy.  Right after this realization, however, we got our first ticket approved!  Bobby was the lead on this bug fix and we are relieved to have an approved fix.

Our plans after break are to continue working on our initial documentation ticket and find other tickets of the bug variety to squash.

Tuesday, February 25, 2014

Reflections On My Progress...

The FOSSils have been attempting to submit our first documentation fix.  Unfortunately, it is not going too well.

First of all- wrapping our head around Git has been embarrassingly difficult.  But at least we are learning now and not later,  right?!

While the Django community is great and there is always someone to help, we can't seem to write documentation that they approve of.  So as a team, we have been discussing moving on to an actual bug.  I'm not sure if this is a good idea or not, but at this point we are sick of Django documentation and maybe finding a solution for an "easier" bug will be more straight forward than their documentation.  It is a bit disheartening- Django seems to have an overwhelming amount of contributors and I kind of feel like we're in the way- but we're just going to have to try harder to help.

Also another ticket that I recently signed up to "own" was fixed 12 hours ago...so that was a fun surprise.

Future plans:
We are looking for another ticket- an actual bug that we could fix *fingers crossed*.  Earlier Tim (a Django core developer) offered to have a video conference with us- I think we might try and meet with him Friday before our SPRING BREAKKKKKK!  And we might have a team meeting over break- I like hanging out with my FOSSils- so it won't upset me too much.

Here are tickets we are considering:  22079, 22078, 22056.


Thursday, February 20, 2014

Refactoring Mindset

Today we have exercises out of our textbook  Software Development:  An Open Source Approach.

Unfortunately I have no idea how to approach these exercises.  The instructions are unclear and I'm not sure where to find...anything useful that's related to the exercise.  I MUST be missing something.

I learned all about "smelly" code in Chapter 5.  A portion of code emits a bad smell when it is not easy to read and could be improved.  There's a whole list of common types of bad smells.  I will list some of them for your perusal:
  • poorly named variable, method, or class
    • A guy who sat next to be in my first CSCI class ever, decided to be "cute" on a test and named his variables: cat, meow, dog, bark, etc- he was deducted many points- the professor was not amused.
  • duplicate code
  • long method
  • large class
  • too many/too few comments
    • apparently too many comments can hide bad code AKA the comments are "used as deodorant".  Is it wrong that I find this section hilarious?
  • data clumps
There are many more bad smells, but I'll stop at these.



So once the offensively smelly code is found, it is refactored.  This means modifying the code to improve its readability, efficiency, or modifiability.  Refactoring usually changes the size of the code base and makes the code more simple.
It is recommended by this text to develop a test suite while gathering requirements for a project and before any coding is started.  This type of software development is called test-driven development (TDD).  TDD is great because it keeps the client in the loop (the client explains the desired end result and what the system needs to do before they approve it).  TDD also motivates effective and focused code development.  Professor Omsted actually talked about this recently in CSCI 360- basically if you write the test suite first- it's like you have the answers to a test- you know what you're going to be tested on!

And then finally there is debugging.  A bug is a defect or flaw in the code base that causes or helps cause a failure (unacceptable behavior).  It is best practice to add a new test to the test suite that addresses the particular bug that has been corrected.

*UPDATE:
The class was given some time to work on the book exercises in class and I did get a little further with help from my classmates.  We were able to find the module in RMH Homebase that displays a shift's notes- calendar.php.  We were able to locate the "ugly" code and defined a new function called "predates(a,b)".


We inserted this as a new feature of the Shift class.
...Annnnnd that's as far as we got.





That could be me in x years!

Tuesday, the Computer Science Department had their 8th (I think?) annual Computer Science Symposium.  It was packed with a lot of familiar alumni faces- Melissa, Lee, and Tatiana.  

I was really proud of my sister and the encouraging speech she gave about start-ups.  Unfortunately I missed half of it due to an embarrassing choking-on-water incident.  The more I tried to stop coughing, the worse it got and I think it threw my sister off- Sorry Melissa!  But everyone told me that she did great and some of the FOSSils get to meet her in person this weekend!

It was really interesting to hear everyone's advice, especially since a lot of these alumni were in our shoes not too long ago.  

The tid-bits I took away from it was to find something you're passionate about and try to excel at it.  My sister LOVES her job- not a lot of people can say that.  I want to be a person who loves their job.  To be excited to go into work.  To like and care about the people you work with.  That is where I want to be- in an environment where I can thrive and learn with people who are encouraging and supportive.  

Money isn't everything.  I've learned this lesson before in my other career and will not repeat it.  I am striving to be happy and if I'm not- I'm moving on to something else.  I'm sure this sounds a bit naive and silly, but life is too freaking short.  I aim to be happy.  I was not happy in my other career, I was miserable.  I kept giving it more time and more time.  "One more year and you will love it!"  I would keep telling myself, but that was not the case- so I did something about it.  Quitting my job and my nursing career path was by far the scariest decision I've ever made, but it was a good one...I think/hope.

Currently, I am interning under my sister's supervision at BrainPower Software and I'm...happy.  Life is pretty sweet and I really can't complain.  Even though I do not graduate until May 2015, I am starting to think ahead more and trying to figure out what I want out of, not only my career, but out of life.  I can't wait to see what happens and where I'll be in x years!

Thursday, February 13, 2014

What's Happening?

Patch it up!

This week we learned all about patches.  What is a patch?  A patch shows changes that have been made (line-by-line).  This is shown with either a '+' to represent additions and '-' to represent removals in the code.  When submitting changes to a FOSS project, patches are the preferred method.

Our first exercise was to diff two files we had been working with in the text without using the -u flag.  With the -u flag, a patch was printed out in my terminal in great detail:  showing which files were involved, printing out the entire code and showing +'s and -'s where code was changed.  When the -u flag was removed, the terminal printed a "<" along with whatever line was modified and then it printed out a ">" with whatever that line was modified to.  For some reason, my output was not the same as the text's, but if I flipped the file order in which I diffed them, then the output was the same:

The books instructions:


My results:

My results when switching file order:
Weird.  I'll have to remember when I'm diff-ing files to put the original one in first.

Our next exercise involved creating a patch for a new file.  To be honest, I'm still not sure I did this right.  Here is the exercise:

Create a patch file that represents a new file, foo being created with the contents bar. Hint: on Linux systems, the file /dev/null represents an empty file -- use that as one of the files you are comparing.

My outlined thought process:  
  1. I have to create a patch file...I'll name it "exercise-7-8.patch"
  2. I have to create a new file "foo" with the contents "bar"
  3. ?!?!?!?!?!?!?!?!?!?!?! ...maybe I could.... ?!?!?!?!?!?!?!?!?!
So I ended up consulting good 'ol stackoverflow and came up with this:

I created a file in my text editor, "foo", and saved it with the contents "bar".  I then ran this command.  After running the command I have a "exercise-7-8.ptach" file with these contents:

So that's right...right?!  That's what this exercise wanted?  Yes?  Cool.

The last exercise is titled "Patch echo". 

Patch the echo command from the coreutils project so that it echoes out arguments in reverse order.

Huh?  Well luckily there were step-by-step instructions to follow, so I did, hoping to understand the objective of the exercise as I delved deeper.

It was all going smoothly until the last two instructions:

$ ./configure$ make
and
$ src/echo is this reversedreversed this is

I was silly and entered the first command in the command line not once, but three times before I realized it was not one, but two commands. *shakes head in shame*
$ ./configure
and
$ make
The last one also needed to be split in two.
This is the command:
$ src/echo is this reversed
This is the output:
reversed this is
That's just sassy.


The article I read was "The Second-Order Effects of Steve Jobs" and this was taken from the January 2012 Computer magazine.  

"For 20 years, Steve Jobs provided us with a gift- technology from the future."

This article gives examples of how Jobs pushed the industry forward.  One example the author gives is when the Mac II came out in 1993 with 256 color levels and IBM was telling its customers "You don't need color:  we've already provided it.  You have four of them- black, [yellow], cyan, and magenta."  That sentence made me chuckle.  

Steve Jobs was an innovator and when he left Apple because the board and management "valued top-down, business-style control over a relentless, quirky, unpredictable and seemingly risky quest to push the envelope of feasibility", the company suffered.  So when Jobs returned, he made it clear that Apple's purpose was to innovate.

It's amazing how far technology has come.  I remember dreaming about products that I actually do own today...because they aren't fantasy...they are reality.  How crazy is that?

````````````````````````````````````````````````````````````````````````````````````````````````````````````````
The next required reading was an article written by Peter Wayner titled "12 predictions for the future of programming".

  1.  GPU's will be the next CPU's. 
    •  I've already encountered this GPU-muscle-flexing in our very own computer lab, so I can definitely agree with this prediction.
  2.  Databases will perform increasingly sophisticated analysis
    • There is more data now than ever and this data is helping companies make big decisions.  Agree.
  3. JavaScript for everything
    • They have valid points.  Seeing as I've never coded a line in javaScript, I immediately went to codeacademy and I'm happy to report they have a javaScript course- which I'm starting the moment this blog is finished.
  4. Android on every device
    • Literally everything is going to have Android.
  5. The Internet of things -- more platforms than ever
    • Literally everything is going to have internet.
  6. Open source will find new ways to squeeze us
    • This is sad.  I don't like it, but it's the way the world works.
  7. WordPress Web apps will abound
    • I need to tinker with WordPress- I've meant to for a while now.
  8. Plug-ins will replace full-fledged programs
    • Don't build from scratch
  9. Long live the command line
    • I've grown to really like the command line.  Plus I feel like a bad-ass when it's up on my screen. 
  10. Dumbing it down will fail
    • Agree
  11. Outsourcing and insourcing will remain deadlocked
  12. Management will continue to misunderstand coder and coding
    • Communication is key!  
I enjoyed reading this article.  This field is so exciting!   Maybe the rest of today should be spent learning javaScript or working with WordPress rather than getting under the covers and taking a nap.  

Tuesday, February 11, 2014

Squashed?

This weekend was suppose to be spent at the CWIC conference over in Mount Pleasant.  Unfortunately I've been sick.  More sick than I can remember being in a long while.  I had a stubborn temp of 101 all weekend (a temperature I haven't seen on the thermometer since I was in middle school).  So long story short- this weekend was awful and I'm beginning to wonder if I have bedsores from the lack of movement (KIDDING- nursing humor).

Team FOSSils has been working diligently on our ticket.  We did not take into account that in order to "fix" our ticket, we had to build the djangoproject.com code (the website code).  This has been extremely difficult.  The readme provided is...lacking...to say the least.  The good to come of all this is that we'll be able to provide a new and improved readme.  Bobby has taken the lead on this and has helped each of us with the building process (Thanks Bobby!).  Meanwhile, Lynn has found another mentor through the core mentorship mailing list.  His name is Tim- apparently he recently finished his employment with Google and has more time to work on side projects.  He has even offered to video chat with us.

For now we are putting this ticket on hold and focusing on another ticket we have taken ownership of.  Here is the Description:

Currently, the "Forms API" section of the Django docs (and in particular the ​Using forms to validate data section of that page), does not document Form.clean(), though the Form.add_error() documentation in that page references it.

There is some documentation about Form.clean() in the ​Form and field validation page, so perhaps the Forms API docs can link there for its information (and/or vice versa).

Django has a great section labeled "Writing documentation" that instructs the newbie how to get the raw documentation, get started with Sphinx, etc.

Django's documentation uses the Sphinx documentation system.  Sphinx is a python documentation generator.  Since these tickets are all about the documentation, we needed Sphinx.

  1. To build the documentation locally, install Sphinx:  $sudo pip install Sphinx
  2. Navigate to the Django-trunk and then to the docs folder
  3. To build HTML:  $make html
Squashed?
No. Nothing has been squashed, but I feel as though we are laying the ground work for future squashing.  So- no, nothing has been squashed, but not for long.

Thursday, February 6, 2014

This bugs me...

Task:  Find the oldest bug that's still open in your chosen project. Write a blog entry describing the problem, with a theory about why the bug hasn't been resolved yet.

Django's oldest ticket is EIGHT YEARS old.  Wowzers. It is not, however, a bug problem- it is a new feature- involving the admin interfaces.  This new feature would make it possible to have multiple fields worth of data entered in a single field.  This is the example they provide:

"For example, a field for a sports stat could be entered into a single field as "XX-YY-ZZ", whereas the three values are actually three separate fields in the DB."

The current triage stage is "Someday/Maybe" so I do not think that this new feature is of top priority- obviously- since it's been 8 years.  But I do see some involvement in the comments from core developers...but that was...ummm...TWO years ago.

Task: Figure out how to create a new account on the bug tracker of your chosen project. You'll need that account very soon.

It was super simple to join Django's bug tracker, but they call it a "ticket system".  I am now registered.



Task: Go through your project's bug tracker and find a bug that you think you might be able to reproduce -- and then try to reproduce it in the latest build. Take careful notes. Report your experiences as a comment to the bug. If you can reproduce the bug, great! Give as much information as you can. If you can't reproduce the bug, great! Give as much information as you can, and ask the original reporter if there are other steps you might be able to take to reproduce the bug.

This ticket reported a bug that produced an error when a field from a subclass was moved to its base class.  One of the core developers responded to this ticket giving instructions on how to reproduce the error step-by-step.  I followed it exactly, but could not reproduce the error.

What I did:


  1. I had the subclass and base class in their original positions --> $ python manage.py makemigrations
  2. Switched their positions, saved the file --> $ python manage.py makemigrations
  3. After running that command on both those versions, $ python manage.py migrate, was suppose to cause the error, but it did not.


Task: Find five bug reports in the new state, and attempt to triage them according to the rules above. Your goal is to do as much as you possibly can, in a short period of time, to make those bug reports as useful as possible to the developer to whom they are assigned. (Note: be sure to follow any triage rules that your project may have defined. If there are no set triage rules, be sure to announce your intentions on the project's mailing list, so that developers can provide you some guidelines if they choose.)

There was one new ticket that was only 3 hours old so I was able to add this "helpful" comment:
"Hi, thanks for reporting.  Do you mind giving more information on how to reproduce this exception so a newbie could partake?  Thanks!"

This ticket did not contain any software versions nor was it very descriptive.  But that was about the only ticket I saw that I could help triage.  Django's triaging system seems to be really organized and people are quick to comment and move the ticket along the triaging line.

Tuesday, February 4, 2014

Reflections on Open Source in Today's World

Our class was assigned to read two articles from opensource.com.  



The first article I read was entitled "Make money and have fun in open source".  Christy Eller, the author of this article, points out the minuscule number of women in computing compared to the number of men.  She explains how she would love for her 11 year-old daughter to become more interested in computers, but the question is:  how are computers suppose to compete with Katy Perry "wear(ing) a candy striped leotard and strut(ing) around through a maze of life-sized lollipops"?! 

She then goes on to talk about how valuable open source tools have been to her career.  She now owns a freelance WordPress web design business, she says "I am making a good living using open source. And it's fun, it really is. I get to make things all day long, beautiful things."  

Christy feels like young girls need role models like herself so that they know what a successful career as a woman in technology looks like.  "Be the change you want to see."  

This was a really interesting read for me- I love the fact that Christy has taken free tools and made a career out of it- what other field could you do something like that?  Make something from nothing while making your imagination come to life.  So. freaking. cool.

 For some reason reading this article reminded me of this.  Maybe we need a lego girl software engineer who goes on adventures.


The next article, "Big data and Hospital OS improve Thai diet" caught my eye initially because of the word "Thai".  

I love Thailand...to the point where I'm borderline obsessed.  I made my first solo backpack trip to Thailand back in 2009, fell IN LOVE with the country, and went back again in 2011.  This summer I am planning on backpacking SE Asia for 6+weeks, so Thailand and I will be reunited once again!  

Another reason this caught my eye was "big data".  My sister graduated with a Discover Informatics...now, Data Science degree- and I have heard her give speeches on big data.  Basically, when big data is analyzed by people like my sister- it can help businesses make better informed decisions regarding...just about anything that has data.

Back to the article...

Dr. Kongkiat Kespechara is a practicing physician in Phuket.  When the Thai government demanded that Information Technology be adopted in all Thai hospitals, but didn't provide a budget for it- Dr. Kongkiat Kespechara decided to use Hospital OS (open source software) in hospitals all around Thailand to accomplish this.  And since he knew that most hospitals would not backup their data- he did it for them with his system.  This led to him having heaps of data from all over Thailand- eventually after several years, he was able to predict what outbreaks were coming.  The main disease that this article talks about is diabetes and how Dr. Kongkiat Kespechara was able to use big data to see the connection between diabetes and white rice, find an older form of rice that would not spike blood sugar levels-and find a way to retail this rice to the Thai people.  

By the end of this process, Dr. Kespechara had added a few thing to his resume...
"Dr. Kespechara is a still-practicing MD, a software entrepreneur, an open source pioneer, a force in economic development, a big data processor, a nutritionist, an agriculturist and a retailer."

It's incredible how open source software can help a whole COUNTRY in it's health.  Wow. Just wow.   
 






Bug Juice / Snowpacolypse 2014

The middle of last week was spent snuggling in bed with my puppy dog, eating obscene amounts of junk food, and progressively getting lazier and...smellier (who wants to shower in the middle of snowpacolypse?!).  

I also watched this clip far too many times.  

I actually did do some productive work- I started following a Django tutorial for creating a basic blog engine.  Right now I'm stuck- having trouble syncing my databases (pretty positive it's a user-error).  

But I digressssss...onward to the meat of this post--> 

Django has a section called the "Ticket system" where you can report bugs or find tickets that you would like to take ownership of and "fix".  Django has a great section titled "Contributing to Django" where there is heaps of information on how to get involved.  After browsing through the "easy-pickings" tickets, our team realized that this was going to be anything BUT easy.

The most frustrating part was reading tickets that made NO SENSE.  We took turns reading the different tickets over and over again, out-loud,  putting stress on different parts of the sentence because the grammar was so horrible.  This further showed me the importance of effective written communication.  I mean, COME ON- at least give an example of what you're trying to convey and YES- grammar is essential- use it.

We quickly realized that we needed guidance.  Lynn reached out in the django-core-mentorship mailing list and we got a very informative response from Russ, a core-developer.  After emailing back and forth, our team decided to go with ticket #17638.

BAM.  OWNED.
This ticket involves documentation.  Here is the ticket description:

"There is one thing bothering me with Django documentation: it's split between topic guides and API reference. Often while googling I get to wrong one and it's not always easy to find another. There should be an easy way to do that: a link at the top/bottom/sidebar. And this way should probably be somehow automatic, so new pages are connected automatically."

So basically this ticket involves auditing the current links between topics and reference guides and adding any links that are missing- this is in the djangoproject.com code, NOT the django software code. 

This particular ticket was opened 2 years ago and has been "owned" by one community member in the past, but it looks like they gave it up for one reason or another.

In response to connecting the new pages automatically, a core-developer commented that this should be done manually and that making it automatic is "not likely to be worth the effort".  

It'll be interesting to see if our team can piece this together.  Even though this ticket is suppose to be "easy"- right now it feels like a daunting task, but nothing that us FOSSils can't handle *she says optimistically*

Tuesday, January 28, 2014

Subversion Under Control

Subversion vs. Git

Last semester when I told my real-world-software-engineering-working-friends that I was using subversion (SVN) for my CSCI-362 project, they were pretty much appalled- going on long rants about why I should be using GIT.  I do not remember the points they made back then, so this was a chance to look into it myself.  Based on their reactions, I will have strong feelings about which version control I use when I'm in the working world.

I have VMware Fusion installed on my computer from last semester and decided to add a new virtual machine for this semester (and a couple of back-ups, just in case).  Both GIT and SVN were very easy to install with commands that I googled.

What is version control?
Version control is a system that allows you to keep a history of the changes you/a team make to a file.  So, for example, if you make a commit and at this point in time, your code is working great.  Maybe an hour later something breaks and you cannot find the fix- luckily you can easily revert back to the file you committed when everything was working!  Both SVN and GIT are types of version control that both get the job done, but in slightly different ways.

GIT is the new and cool way of doing version control- which was obvious by my hip real-world-software-engineering-working-friends' earlier reactions.  GIT was developed by Linus Torvald for Linux kernel development.  A lot of googling leads me to believe that GIT is also the most popular version control available at the moment.

GIT is distributed.  And that means...  
Instead of "checking out" a repository, you "clone" the repository which means you get the latest version and all the history associated with that project.  This means you have a complete repository!  Which in turn means that instead of having a central repository (like SVN), GIT has multiple repositories.  The benefits of having multiple repositories is that if something is wrong with the main repository- developers can still work and commit their code locally and then push it up when the main repository is fixed.  A "push" in GIT is like a "commit" in SVN.  Commits in SVN can take time, while commits in GIT are very fast.  Working with GIT is faster because there is no need to communicate to the central server!  And (this point I do remember from my real-world-software-engineering-working-friends) is that you can work OFFLINE.  Very cool.

Team FOSSils has decided to use GIT this semester to broaden our knowledge and to show how "hip" us FOSSils really are.

Thursday, January 23, 2014

Joining the Project

1) Select an IRC client and join the channel for your Team project; peruse the history and listen to current traffic; blog about your experiences.

I have had no experience with an IRC client, so I googled "best IRC client for Mac" and got a couple of choices.

I decided to go with Colloquy.  
The UI is great and it feels like a Mac app.  

After registering my "nick", all systems were go.  I joined the #djano room and the #django-dev room.  The #django room for users was very active, but I was disappointed to see that there was not a lot of activity in the #django-dev room.  I did not interact, with the community I just "listened".  There was one user in particular that wanted to use Django on their site and was getting a lot of help.  I feel confident that if my team has any questions- answers will readily come from this community. 


2) Join the electronic mail list and/or newsgroup for your team project; select an interesting thread and explore it; blog about your experiences.

Our team collectively decided to join the following mailing lists:  django-users, django-core-mentorship, and django-developers.

Under the django-developers there was a ticket request review which caught my eye- after clicking and glancing at it- I am beginning to see how we will interact with the community regarding our bug fixes.   I don't think it's required to put your ticket revisions on the mailing list, but the contributor got a lot of feedback regarding his fix which I'm sure our team would appreciate.

The Reading

Our class is using the text Software Development:  An Open Source Approach.  Much of Chapter 2 in this text was review- as a class we've already talked about this material or seen it somewhere else.  I did think that the IRC etiquette lessons included in Chapter 3 of the online text and in Chapter 2 were good to look over.  Most of it was common sense, but still good to review.  Chapter 3 was more "getting started" material and (mostly) all review.  I will make it a point to go back and read The Bug Tracker section more thoroughly within the week.

Thoughts

Two of my friends who are applying their BS's in Computer Science to software engineering in the real world, have very different work environments.  Friend A works at a place where there is a strict no-finger-pointing-policy, while friend B works in an environment where finger pointing is part of that company's culture.  I'm assuming that both of these company's get their work done, but it is done in such different ways.  Pleasant work environments vs not-so-pleasant work environments.  This kind of goes back to the reading from last time-how the author thought that a charming leader was key to a successful project:  he fluffed his beta-testers/co-developers when needed (praising them in emails, etc) and charmed them into doing hard work.  Here he's clearly trying to create a pleasant "work environment" or I guess- pleasant community-experience in this case.  Let's just stop pointing fingers and get the work accomplished.  Shall we?!

Tuesday, January 21, 2014

FOSS Experiences and Reflections

For this blog post we were required to go find a new piece of open source software that interests us. Install it, and report back with any problems.

Our team collectively decided to install Django.  Lynn and I decided to follow a tutorial appropriately titled How To Tango With Django.  This tutorial is very thorough and I assumed it would be relatively easy/quick to work through chapters 1 and 2 of the tutorial, but we all know what happens when we assume...

Everything was going very smoothly until I was to install the Python Imaging Library.  Unfortunately I had dependency issues to work out.  I worked around this by installing Homebrew.  Homebrew is a package management system that makes installing software on my Mac a lot easier.  (It's also FOSS!)  Then typing in these commands:

$brew install gcc48
$pip install Pillow

These commands helped me finish installing the Django software successfully.  

I also downloaded and played with GIMP.  GIMP is an acronym for GNU Image Manipulation Program, it is a image editor.  This installation was very quick.  I had three images that I needed to edit and this software really impressed me.  Also, any questions I had were easy to find answers to as there were a ton of tutorials on anything and everything.  GIMP seems to have quite the following.

Required reading:  The Cathedral and The Bazaar

The author of this 30+page essay is Eric Steven Raymond.  You can view his resume here.

This whole piece is about how the author inherited popclient and the lessons he learned as it evolved into a completely different program, Fetchmail.  During this process he tried to emulate Linus Torvald's style of development- "release early and often, delegate everything you can, and be open to the point of promiscuity". In all, Raymond provides the reader with 19 lessons that he learned throughout this process.  

Raymond quotes Brooks- an author we read last semester- the author of The Mythical Man-Month-throughout this piece,  and usually agrees with him up until the chapter titled "The Social Context of Open-Source Software".  Raymond states that if Brooke's Law ("adding manpower to a late software project makes it later") were "the whole picture, Linux would be impossible".  Raymond goes on to explain the concept of "egoless programming" which the author of The Psychology of Computer Programming, Gerald Weinberg, observed.  Egoless Programming:  "in shops where developers are not territorial about their code, and encourage other people to look for bugs and potential improvements in it, improvement happens dramatically faster than elsewhere".  Raymond goes on to say that the bazaar method harnesses the full power of "egoless programming", negating the effect of Brooks's Law.  Brooks Law is not the be-all and end-all.

What I took away from this piece:
More heads are better than one.
Always listen to your customers.
Treat your beta-testers and co-developers well.
Use your charm...WINK.

Favorite lesson/ quote:
"Perfection (in design) is achieved not when there is nothing more to add, but rather when there is nothing more to take away." - Antoine de Saint-Exupery


Thursday, January 16, 2014

My FOSS Preferences

The class teams are to choose three open-source projects that we would like to participate in.  The tricky part is that we need to choose projects that have active communities.  So TeamFOSSil's prerequisites for the team project are as follows:  the open source project has to be written in python (member preference) and has to have an active community.  This shouldn't be too hard to find, right?!

Number One Choice:  Django 

The "D" is silent- pronounced "Jang-oh"
It was suggested by Lynn that we look into Django.  I had no idea what Django was in regards to open software.  The first thing that popped into my head was Jamie Foxx in that Quentin Tarantino movie- EXCELLENT movie by the way.  "Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design."  In a nutshell, it allows you to quickly build high-performing Web applications.  It was originally developed to manage several news-oriented sites for The World Company  of Lawrence, Kansas.  The framework was named after guitarist Django Reinhardt who is often regarded as one of the greatest guitar players of all time. Django has some bragging rights.  Here are a few sites that use Django- Instagram, OpenStack, Mozilla,  and (my personal favorite) Pinterest. Django is written in Python and has a VERY active community making it my favorite choice for this semester's project.  It also seems very newbie friendly- another bonus.

Choice Number Two:  SaltStack

Bobby vaguely remembers hearing about this choice at some CSCI talk.  SaltStack is a new approach to infrastructure management- it runs within seconds, scalable enough to manage tens of thousands of servers, and can communicate with these servers within milliseconds.  For newbies, the Saltstack site says- "There is no need to introduce yourself, or ask permission to join in.  Just help and be helped."  I like it.  There is a lot of documentation, an active community, and even a YouTube channel!  Plus it meets all of our prerequisites because it is indeed written in Python.  Oh snap.

Choice Number Three:  Gramps


This choice started off as a joke since it would fit perfectly with our FOSSils team name- Gramps just goes so well with our old team member theme, but it could in actuality be a decent choice.  This is free and open source genealogy software.  This is software for genealogists or genealogist hobbyists- a way to keep them organized.  Now the community for this choice is a little lacking- definitely nothing like the community for Django.  The site says that the filing and tracking of bugs has low traffic, but that discussions on using Gramps and issues relating to software development have medium traffic.  It is written in Python as well- but we have two much much better choices above.

The preface of the book reiterates why participating in FOSS is advantageous.  Alright. You've convinced me.  The preface also goes over class organization, a sample syllabi, and other support and guidance.  

Chapter 1 gets more interesting.  From last semester's readings, I was aware that software failures do happen, but for some reason I was still a little shocked to read that according to the 2009 CHAOS Report, only THIRTY-TWO percent of all software projects were completed on time, on budget, and with full functionality.  The text lists many reasons for these software failures, but it singles out "improper choice and deployment of an effective development methodology" as the main culprit.  

I will sign off with the
Four Freedoms of FOSS: 
  1. Freedom to use
  2. Freedom to modify
  3. Freedom to distribute
  4. Freedom to improve

Monday, January 13, 2014

Productively Lost?

A new semester, new required texts, new team members, and the same (one and only) Dr. Jim Bowring.  This semester CSCI-462 is relying partially on an online text.  Teaching_Open_Source 0.1 - Practical Open Source Software Exploration:  How to be Productively Lost, the Open Source Way.  This text aims to teach students and self-learners the basic skills of open source development  through real involvement in meaningful projects.  Chapter 1 explains why a student/ self-learner would need this text.  David A. Patterson, a computer science pioneer, advocated for the inclusion of courses in open source software development in computer science curriculum.  Unfortunately the world of academia did not heed his advice, as the text puts it, "because it's hard".  The text stresses that "the skills required to succeed in an open source software project are the exact same skills required to succeed in any large software project."  In short, this is real world preparation folks.   The text also stresses that one of the most important skills a developer must possess is the ability to be "productively lost".  Last semester I was mostly lost, so hopefully that will be of the productive variety this time around.

And as this may show up on the ONLY test this semester as a bonus question, this handsome gentleman is David A. Patterson.
He is most known for contribution to RISC processor design and his research on RAID disks.  He was president of the Association FOR Computing Machinery from 2004-06.  He has also co-authored six books and has been recognized by about 35 awards for research, teaching, and service.

At this point I'm happy with my post and want to stop writing, but I'm 200 hundred words short so....

In Chapter 2, we get a preview of what we will learn in future chapters.  Here are some of the covered topics:  version control, build management, documentation, bug hunting, and the mechanics of fixing code.

So what is the value of sharing?  Why is FOSS valuable?

  • Shared development costs- time is money and this time can be spread out over several individuals. 
  • Users can fix their own bugs...OR find other people to fix their bugs for them.  This section provides a great analogy between a car fix and a bug fix.  
  • Arguably better software- since there can potentially be many more people working on a FOSS project than the number of developers any company could pay.  But didn't we learn last year that more man power doesn't necessarily mean better software? I guess that's why "arguably" is the lead on this header.
  • Software that outlives its creator- code that isn't shared can turn into abandonware and die with its creator, but FOSS projects have a chance to be reborn.
  • The freedom to fork- ummmm, what?  Apparently this means taking a project in a new direction without asking for anyone's permission.

This semester I am on a four person team.  My other team members are Lynn Kitchner, Chris Moore, and Bobby Jenkins.  I'm pretty excited to be on a team with such cool cats.  Since we are all a little older than our other classmates- Chris suggested we call ourselves the FOSSils.  I obviously love this idea and hope that this will become our official team name, but we have yet to vote.