Laszlo Balogh

Contributing to others' code...

Wed, 19 Apr 2017 02:13:38 -0600

For our Turing Mod 4 open source contribution, I wanted to really contribute to the Boulder Food Rescue robot code (Link to GitHub).
This is a work I have started a few months earlier. As soon as we started learning Rails, I wanted to be exposed to code written by others and try to get to the level where not only I feel comfortable modifying code written by others, but others are also comfortable merging in my contribution.

Hasn’t happened yet, but work in progress.

Personal take:

Testing being my core interest in software development, I figured what best way there is to get familiar with a codebase, then writing some tests? Not really touching the codebase, but adding code that would “only” exercise it, yet it will force me to go through various sections of the codebase in a very detailed way, so I can write efficient tests.

I could bring up a long list of reasons why I haven’t been able to stay as strongly engaged as I originally planned, but to save everyone’s time let me focus on outlining my approach here instead. :-)

My process:

1. Read the documentation: let’s understand what details are already available, if there are instructions to create a local set up, are there any other non-obvious, but important details highlighted.
2. Follow the documentation to create a local set up: I thought I was pretty good at following instructions. I was able to set up a local version and get it up and running, yet I missed an important details: that the database.yml.dist file that is included in the repo is only for common starting point, everyone should update it based on their own environment, but we should NOT check in the updated and customized database.yml file. Clearly an error on my part…
3. Run tests locally and make sure the results match with everyone else: here I saw different results. All existing tests were supposed to pass, yet I had 13 errors. When I reached out for confirming if I have the latest code and confirm other details, we identified that setting up my local environment with SQLite instead of PostgreSQL made a difference. All tests were passing and I got the same results once I updated my database configuration. So I will be using PostgreSQL. :-)
4. Let the team know which item I will be working on first (we had a list of features which had no test coverage at all): straight forward. I also opened a [WIP] pull request to get my PR in the queue.
5. Review the codebase myself and collect questions: I just that and collected a long list of questions. To review them, I met up with the team here in Boulder, CO. Due to a complex database structure, the conversation went slower than expected, but it was definitely very helpful. I walked away with a much better general understanding of how the site is set up and most importantly full confidence in the capabilities of the team members already supporting this effort. Hats off to all the patience and support that the volunteer developers demonstrated!!!
6. Ask for confirmation after writing one simple test: this step that I thought was going to be simple and straight forward has proved to be a longer chain on conversation both through GitHub as well as through Slack. First I made any rookie mistakes that I never thought I would make. Starting with the previously mentioned “checking in the customized database.yml file”, through changing a few lines of code, then commenting them out to switch to some other piece that I ended up checking in along with the springkled in commented out code. How messy that is? Come on Laszlo, you can do better!!!
7. Adjust based on feedback: concluding our first round of conversations, I started focusing on writing a happy path, “simple” test case: volunteer with assignments to schedule an absence. And this is where I am right now.

…STAY TUNED…

Going forward:

My plan is to set aside at least a couple hours each week to dedicate working on this project. That will be the best for everyone involved. It will help me to stay on track with my planned contribution and on the receiving end finally the enthusiastic team that is already working on this project can see some real progress and contribution from me…

The feeling of going live: Deploying a Rails application

Tue, 20 Dec 2016 01:13:38 -0700

Yes, it happened!

Every once in a while we have to pause, look back and try to be proud of what we have acoomplished. On my bus ride this morning, I am doing just that. For others, I might be the crazy person, who opened his laptop, only to wonder around, look through the window, seemingly lost in the views of the mountains to the West. But in my head thoughts are running around: I have now two projects live on the internet. So far none of our work was accessible by others. At most we ran applications on our laptops. Other than through localhost, nobody could see what we have been working on. That is changing now, given that we just deployed our first two applications to Heroku this week. Wohoooo!

This is definitely one thing to be proud of, however this is not the real source of my pride. Not to discredit others’ efforts, but nowadays with all the online tutorials avaialble, lot of people could hack something together and push it to the internet. So why do I feel so proud, then? Here are the two main reasons:
1. I know exactly why and how my application works:
This is a huge difference from any implementation where one would just Google and hack the details together. In the weeks prior we were building our applications the hard way: without Rails building much of the code framework for us. It was long hours of coding well spent!
2. Making progress:
My second rails app Job Tracker works much better than the first one. I am not saying this second one is perfect. I wish I could. But the fact is that it is a much stronger implementation than my first one and that is a momentum I will try to build on.

I still have a long list of potential improvements for Job Tracker, including:
- refactoring all controllers to avoid long methods,
- making sure all ActiveRecord methods are called from the models,
- increasing test coverage to cover corner cases and confirm all page details,
- further simplifying test setup with factory girl,
just to mention a few…

Starting from now on, I will have a Projects page capturing what I will be working on and serving also as my online portfolio. Please don’t hesitate to share any constructive comments regarding any of the projects as well as how to make the Project Portfolio page better. Thank you! :-)

Jekyll blog post: which files are changing?

Mon, 12 Dec 2016 01:11:46 -0700

I have been working with Jekyll to update content on my site for a little bit more than a month. By now the overall design is set, so the only update right now is pretty much limited to new blog posts. Might be a new page in the near future, but that would trigger a very similar change list.

My current choice of FTP client does not offer a feature to identify the list of files which changed and I just simply don’t want to copy the entire site content to the server every time I create a blog post, I wanted to summarize the list of files, which are changing every time we create a new blog post with Jekyll.
Though the list of files might differ based on the overall design of the page, so for this post I used the template of my site as a reference.

Since the site is a structure of static webpages, once we make a change and run the jekyll build command in our terminal, we will get a new set of files in our _site folder.

Jekyll has a nice feature: launch your local webserver with the --watch option as jekyll serve --watch and it is automatically serve the updated content for your whenever you visit your site through localhost:4000. For our blog post update it will also allow us to check in our browser how the new blog post will look like, without messing with the content on the server.

Once we are happy with the blog post and it is ready to be published for the world to see, all updated content will be waiting in the _site folder. For an average blog post (like the one you are reading right now) here is what is involved from a content point of view:

Written in markdown
It has categories assigned
It has tags added
It includes a few images for illustration purposes

Based on this list of post content details, here is an overview of files and their location which will be updated by Jekyll.

Folder name	Content description
/	index.html is the site's Home page. I have a link on it taking visitors to excerpt of blog posts, so this is definitely going to be updated.
/	feed.xml is updated to reflect the latest post. Tools which collect updates from sites (such as RSS feed readers, automated newsletter delivery services, etc.) rely on the content of this file.
/	sitemap.xml is updated to reflect the latest file structure of the site.post. Online tools, such as Google's search engine utilize this file to properly index the content of a site.
/blog	New HTML file that is the new blog post
/categories	index.html updated with the latest blog post added to the selected category/categories
/images/posts	My choice to collect all images which I used in any blog post. This can be whatever folder your hear desire...
/tags	index.html updated with the latest blog post added to the selected tag(s)

This list will definitely grow in case you add custom JS, CSS, update already existing blog posts, pages. For now, happy blogging and let me know how your site updates are going. :-)

ActiveRecord association extensions

Fri, 09 Dec 2016 11:48:48 -0700

Hello from after Mod2 project submission!

We just finished our first project within Mod2. As referred to previously, it was the Bike-Share project where we were tasked to develop a web application that utilized a database populated from San Francisco’s bike share service data with stations, trips and weather details and provuded access to content of the base. However access to the databse content wasn’t only through standard routes index, new, show, edit, our implementation also included a dashboard functionality.

It’s been quite an effort and in the process leading up to our project review on Thursday, I learnt a ton! Looking back: it is just simply amazing how much one can learn in a single week. Wow. This alone makes me very excited just thinking about what I can still learn here at Turing

Since again I’ve learnt a lot and just as after previous projects I feel I am that much smarter again, I thought I would share here something that just cliked during this project and what I really think is a cool feature.

Our project relied very heavily on large data sets, which were stored in various tables within our database. In order to get the necessary data out of our database, we had to set up the necessary associations in our models, so that we could utilized the necessary ActiveRecord quiries. That is when I learnt about Association Extension. If you rather explore it and read it for yourself, simply go to the ActiveRecord::Associations::ClassMethods documentation

For reference, this is how our data was structured within our database (used SQL demo from Ondras Zarovi’s site):

Let’s go through my favorite part here using our stations and trips tables. In this case, each trip had a start_station_id (unique id of the station where the trip started) and an end_station_id (unique id of the station where the trip ended).

We set up the has_many association in our station model to be able to find all trips which started at a particular station through start_trips and to find all trips which ended at a particular station through end_trips.

class Station < ActiveRecord::Base 

  has_many :start_trips,
            class_name: "Trip", 
            foreign_key: "start_station_id"
  has_many :end_trips, 
            class_name: "Trip", 
            foreign_key: "end_station_id"
  
end

Before diving in deeper, a simple example as to how association extension differs from class methods and instance methods.

From coding point of view here is a list where setting up the association extension differs from class methods and instance methods:
1. Definition: within a do...end block attached to the association definition (see example below)
2. Calling: append to the association call, just like any other ActiveRecord methods you would use
3. Reference: since this extension is within a block that belongs to an association, using output of that association is readily avaialble for the extension method, no need to call it (ee code example later in this post)

class Station < ActiveRecord::Base 

  has_many :start_trips, 
            class_name: "Trip", 
            foreign_key: "start_station_id" do
    def say_hello
      "Hello from the association block!"
    end
  end

  def say_hello
    "Hello from the model!"
  end

end

How would we call these methods? Since our stations and trips tables are already populated with data, for simplicity here, I use Station.first as our station object to call our methods on.

So far not much value add moving say_hello and make it an association extension. Let’s take a look at an actual feature request that we had to implement so we can see how different the code would be in that case.
For this next example, I picked a feature to look up the date when the most trips started at any given station.

class Station < ActiveRecord::Base 

  has_many :start_trips,
            class_name: "Trip",
            foreign_key: "start_station_id" do
    def date_of_highest_count
      group(:start_date).order("count_start_date DESC").count(:start_date).first.first.to_s
    end
  end

  def date_of_highest_count_of_trips_started
    start_trips.group(:start_date).order("count_start_date DESC").count(:start_date).first.first.to_s
  end
    
end

Then once more let’s jump over to our Tux console to see what this implementation offers:

Though both the date_of_highest_count and date_of_highest_count_of_trips_started methods deliver the same results, but at this point I prefer the association extension implementation for the following reasons:
1. Don’t need to call start_trips when I write the code for the date_of_highest_count method
2. Better separation of functionality: by appending date_of_highest_count to start_trips I know that by calling date_of_highest_count, my search for the date is within the list of trips started at this station.

What do you think? What is your preferred way of implementation?

How to add our own task to Rakefile

Sat, 03 Dec 2016 23:21:03 -0700

This post would not have been possible, have Robbie not shared the initial details to set us to the right direction. Thank you Robbie!

Still just started on our Mod2 project Bike share and as we were tackling one challenge after another, we came across the requirement to import data into our database tables from external CSV files. The requirement called for updating our seed file and as it is we tried to implement it as a new rake task.

For reference, here is our folder structure. We had to work with two files: seeds.rb and our Rakefile.

Starting with an empty Stations table within our database, we were expting to be able to load all 70 rows from our CSV file and set up the framework to load later on much larger datasets from other CSV files. We used a tool tux to check database table content as manual verification of our steps.

In order to implement the import functionality, we needed two things:

Add our own import_csv method into our seeds.rb file
Create a task in our Rakefile and link it to the method in our seeds.rb

Step 1: Creating our method in seeds.rb

A few key details we had to pay attention on here:
* make sure to require all dependencies, such as CSV and our models
* define our method as we would in any Ruby class

require 'csv'
require_relative '../app/models/station'
require_relative '../app/models/city'

def import_station_csv
  # CODE TO PARSE INFORMATION FROM THE CSV FILE
  # AND
  # WRITE IT TO THE DATABASE Table

  puts "Imported Stations to Table." # Our short message in the terminal
end

Step 2: Link our new method from the Rakefile

We had to define a new task by adding the following piece of code with paying attention to the following key details:
* Create the appropriate link to our seeds.rb file through require_relative
* Add desc so our new task will have its own description in the task list (see screenshot later in this post)
* Define our Rakefile task name through task, we called it import_csv
* Call our CSV file import method, in this particular case import_station_csv * Adding our new task under namespace :db would make our task to be called as rake db:import_csv. Defining our new task outside of this namespace would make it avaialble as rake import_csv

namespace :db do
  require_relative "db/seeds"
  desc "Import CSV to table"
  task :import_csv => :environment do
    import_station_csv
  end
end

In order to confirm that our new task is available with all other rake tasks, called rake --task in our terminal:

Only two more steps left:

Run our new rake task: rake db:import_csv
Confirm through tux that our database table Stations have been successfully updated with all 70 entries

Many thanks again for Robbie for setting us to the right direction and for my project team to work through the implementation!

Keep on coding!!! :-)

When postgres install fails...

Fri, 02 Dec 2016 13:49:30 -0700

Started working on our first project in Mod2. Building interface to present various forms of data from SF Bay area bike share service that we download from Kaggle. But first things first: we needed to make sure our development environment is up and running. That is where the first problem came…

On previous projects in Mod1, we pretty much worked in Ruby and other than a handful of useful gems (pry, minitest), there was not much we had to make sure were working, let alone up and running.

In Mod2, very different: webserver, database, all is preared to accomodate a test environment as well, so more things to juggle. Expecting the straight forward execution of bundle came to a surprising halt with the error message

An error occurred while installing pg (0.19.0), and Bundler cannot continue. Make sure that gem install pg -v '0.19.0' succeeds before bundling.

Looks simple enough.

Except when tried to run gem install pg -v '0.19.0' still no luck. No panic! Google is your friend! :-)

I came accross a discussion on the well-known site stackoverflow with the solution to my issue. If you don’t want to read through the entire conversation, here is a list of steps that helped to solve my issue:

brew update

brew install postgresql

gem install pg

Then to be sure run bundle to confirm pg 0.19.0 has been installed correctly. Now on to the next step…

Life after Wordpress: Jekyll update

Thu, 01 Dec 2016 15:40:18 -0700

Greetings!
Finally the updated site is up and running! Have you signed up for email updates already? If not yet, here is your chance…

One less thing… :-)

Originally I started on a quest to rebuild my personal website on a new platform, stepping away from a Wordpress-based implementation. I decided that I will rebuild the site based on Jekyll. To read more about my thought process, jump to my other post: How I roll.

If you are still with this post, then here is a short update of how the updated site compares to the previous version.

Key functionality to support:
- Accomodate simple blog => Accomplished (Link to blog)
- Showcase photography portfolio => Accomplished (Link to Photography page)
Manage content => NR: there was no specific goal here
Currently to push myself to get more familiar with Markdown language, I type the blog posts using markdown. When needed, I mix up HTML and markdown in a single document, add JS as necessary. Definitely a great way to get more comfortable with a broader range of tools. So far making progress…
Dynamic vs Static content => Accomplished
The content I am hosting, the structure of static pages is perfect.
Users => NR: there was no specific goal here
How complicate to work with and/or learn => Accomplished As I mentioned above under point point 2, so far any technical skills needed, I was able to cover, no concern there. I also expect the more I advance with my studies at Turing, the less of a concern this will be.
General page load => Accomplished See later in this post more details on this. Definitely significant improvement!!!
Site design simplicity/complexity => Accomplished I am very happy with the latest theme that I pick up for this site. I ended up customizing it a tiny bit, but the general design what the theme already included is what you see throughout this site. How do you like it? Personally I like it a lot! Feel free to share links in the comment section below to other sites with similar simple designs.

As promised, here is some more detail about the general page load improvement. Main page load time was floating around 6 seconds with the old Wordpress-based implementation. With the current static page structure, the main page load time is less then one second most of the time.

I used a handful of sites to prepare reports about the pages. Besides the page load speed, Jekyll takes care of a lot of the document structure details which were missing or improperly set up with the Wordpress theme I used previously. That is definitely an added bonus here. Without posting all the screenshots from all the test sites, here is a pair from one of them. This shows very well the difference between the old and new design.

Old implementation test result:

New implementation test result:

Overall I am very happy with the results.

One detail I am still trying to get a better handle on is updating the content on the server side: The FTP client I have been using does not offer feature of syncing the updated content between my computer (local development environment) and the server (production environment). Fortunately there is not many files which are changes once Jekyll rebuilds the site, but long term having a file structure sync solution would be very helpful and necessary to save time. Any suggestions are more than welcome. :-)

Welcome to Turing

Tue, 26 Jan 2016 05:38:42 -0700

As I am only two days away from starting Mod2 at Turing School of Software and Design, I figured I add a post here with a few thoughts that I think might be useful for others who will start Mod1 in the future.

There are plenty of sources of good words, suggestions, advice and information. For this reason I will try to offer a summary of my unique perspective. I want to highlight what I think helped me and could have helped even more have I spent more time with prior to joining Turing.

But before I would get started, here is an initial list of sources of information that is available to you already prior to joining Turing. If you haven’t been aware of any of these, let your contact know or feel free to reach out to me and I would be happy to set you to the right direction.

Turing website: turing.io. Very obvious… :-)
Info night: Usually held on-site. You will receive plenty of details during this session and there are always people there to ask questions. Not only from Turing staff, but current and maybe even former Turing students as well.
Turing handbook: Make sure you read it through and familiar with its content. You will spend seven months of your life in this environment, so it is good to read it through at least once
Turing student advice: You would receive it from Turing staff. It is a list of suggestions, advice collected by previous Mod1 students. Maybe not all those points will be applicable for all new students, but in general they are all spot on as every single one of them is based on recent experience with the program.
Prework guide: You will be contacted by your assigned prework guide, which is awesome. As you work your way through the prework assignment, you might have questions about that content or about Turing in general. Your prework guide will be a useful source of information.

Since from these various sources you are already going to receive plenty of input, here is my own list based on my specific situation. Some items might still be applicable to you as well:

Becoming a MAC person: I have always been a Windows user mainly driven by the fact that in the corporate world that has been the OS of choice. Don’t underestimate the burden of switching to a brand new OS and computer system. If you can, make sure you pick up your laptop as soon as it is avaialble and get familiar with your new working environment. It is very frustrating, when you need to spend time googling how to do simple things, such as
- how to install and remove applications,
- finding, viewing and editing various content types,
- delete instead of backspace,
- general interface of the computer: touchpad for example and how you can use it efficiently,
- adding and removing new drives,
- if you had an NTFS formatted backup drive, how to write to it,
- etc…
Prepare the family: This point is more to someone who will be joining Turing as a parent. As soon as you are accepted to the program, start preparing your kids. Especially if they are old enough to have meaningful conversations. In our experience repetition (drills if you wish…hehehe) is the key here. The more you bring this up to your children in various situation, the better off you will be later on. Simple things, such as the family will not be going out for dinner that often. Or Santa might not bring that many presents and it will not be because you behaved bad. Kids will eventually understand it, but it will take time. Why not start those conversations early on and set their expectation? Kids will even show their own way of appreciating the heads up and they can also help in their own way: “I will put this toy back to the shelf, so we can save money because Daddy/Mommy doesn’t have a job…” Kids are smart! Being less materialistic: make sure you hear plenty of times that you will not be spending that much time at home and with them in general. And that will not be because you don’t love them. Let me know how it goes!
Drills: There is a very good reason they exist and there is a very good reaon they are called “drills”. Do them whenever you can. Even if you go back doing drills of a subject only weeks after you learnt about, still do the drills. There is never enough repetition you can do to become a better programmer. At least in my opinion. Drills helped me a lot to get more familiar with basic concepts and avoid googling them when I had to work on projects.
Help others: This is a great thing for obvious reasons with the extra benefit of helping yourself while hepling others.
- Troubleshoot code: You will see others’ code that is likely not working and it will help you to improve your troubleshooting skills working on something you have never seen previously.
- Strenghten your knowledge: It is one thing to know and understand something, but it is a whole new thing explaining it to others. It will help you to confirm that you really know the topic or will help you to identify that your knowledge is not as rock solid as you thought it would be.
Don’t be afraid of the empty code editor screen: You will hear this mentioned by Jeff countless times: if you get stuck, just delete all your code and start again. Sounds simple, yet turned out to be a challenge for me to really practice it. I got caught up in the “my precious code, how could I delete it” endless circle.
With all honesty that “precious code” was non functional and I was stuck for way too long trying to make it work.
The first eye opener came, when on my first paired project, after we spent close to an hour trying to resolve an issue together, we decided to try troubleshooting on our own. I tried to make the already existing code work, while my project partner ended up resolving it by following Jeff’s advice: rewriting that method from scratch.
On my next paired project, I ended up taking a leap of faith and in a similar situation, I was the one who followed Jeff advice, while my project partner tried to make the already existing code work. Again rewriting from scratch took us to the next step.
So please, have confidence in yourself, delete what is disfunctional and don’t be afraid to start all over again!
Opening up as an introvert: If you are an introvert person, just like me, first you will find the significant community involvement at Turing overwhelming. But it will also help you in a way. Soon you will also recognize that there is really no other way than going forward.
That being said, make sure you try to participate in everything that is available to you. That will help you to get to know other people whom otherwise you would not talk to because you are a very reserved person.
This is actually a topic that would warrant its own blog post, but for now let’s just leave it with sharing with the summary of my experience: as much as it has been an effort for me to open up and talk to others about all kinds of topics, I see the benefit as well. Not only the personal effort that goes into it.

Thankful

Mon, 25 Jan 2016 01:48:03 -0700

With the turkey already partially eaten, the leftovers carefully packed to provide reliable food supplies for the next two weeks, I did a quick math for the first eleven months of this year.

Wow, what a year this has been! Again!

Of course I am thankful for our family and our friends and for our life in general. If I pause here for a second, based on the Wikipedia description of what Thankgiving is about these days would be

Prayers of thanks and special thanksgiving ceremonies…
…after harvests and at other times.

Therefore trying to be more specific for this year (2016) I have to say that I am very thankful for the unique experiences this year has brought to us.

Experiences are never really mentioned. Experiences seems to be completely underrated in the general public’s mind. Yet they are the “things” we will have with us independent of how many material possessions we have and if we are up or down.

For this reason alone I think experiences are extremely important. Especially that nowadays it seems having new experiences are becoming almost luxuries: afforded the opportunity of exploring things beyond one’s daily fight for basic necessities is beyond reach for many.

Fortunately we had our fair share of new experiences this year. And for that I am extremely thankful.

Happy Thanksgiving!

And this how I roll...

Fri, 08 Jan 2016 08:04:23 -0700

After using Wordpress for a while, I tried to look for something simpler, something with much less overhead for my site. As I am in the middle of learning programming in Ruby, when I found Jekyll, I was very much into giving it a try. It also means that this post that you are reading right now is nothing more than a static HTML page, generated by a simple jekyll build command.

So far I love it.

Everybody has their own wish list. For my search I had a few very simple things to consider:

What purpose should a new framework serve for my website?
Though the list might grow, but currently here it is:
- A simple blog where I can share thought every once in a while about anything (mainly topic around programming, running, photography, travel sprinkled with some random thoughts…)
- Showcasing a photography portfolio
Not a huge list by any means…
How to manage content? In my case currently I am in full control of content, hosting and anything else that comes between you seeing this page in your browser and the thoughts in my head. I don’t have an army of editors and other site contributors whose access to the site would have to be managed and any changes I will make, I will make it locally on my computer (development and test environment if you wish…) and upload to the server only after passing all evaluations. For this reason a solution that requires some technical or even programming know-how is perfectly fine.
Dynamic vs Static content My content is static. I hope it will change in the future, but for now a few static pages are perfectly OK.
Users Since currently I am the only one need access updating the site, there is no need to manage user database
How complicated will it be to learn/work with? I am already picking up Ruby and diving deeper and deeper into web development, so I feel comfortable with what Jekyll had to offer.
General page load To be as fast as possible. I think we can all agree that nowadays nobody has the patience to wait for websites to load… For this one key detail that is important is the number of items need to be processed to generate the content let it be
- any kind of magic on the server side
  AND / OR
- actions your browser need to take.
Site design simplicity/complexity
I wanted to switch to a very simplistic design, so I will not need complex templates/themes that somebody developed with the intention to fit a wide variety of needs and therefore complex and covers a more features than I will really need in the foreseeable future. I am not saying all wordpress themes are evil. They are all good for the purpose they were built: serving needs of a larger audience. For now, I wanted to focus on loading my content as fast as possible and present it in a minimalist design.

To be continued…