Codeene

On Friday 4 September, my colleague Ella and I were invited to take part in a Craftathon at Makers Academy, where we had both trained to become web developers. 

A Craftathon is similar to a Hackathon, in so much as you have a brief and need to work quickly as a team over a short period of time to create an answer to said brief. What makes it ‘craft’, rather than ‘hack’ is that you need to have written quality code that has been tested. In Hackathon’s, it does not matter what it looks like under the hood, just that it answers the brief. A Craftathon should give you a minimal viable product, however that product should contain clean code and be bug free.

A cohort of Makers Academy students had recently graduated, so the Craftathon provided them with the perfect opportunity to improve on the skills they had learned over the past 12 weeks, in a more practical environment. 

Four teams of five alumni were given a brief (in the format of a cucumber test) to create a website that will allow people to book trips to the moon. A back end to the site would let the administrators see how many tickets have been booked. 

Ella and I were involved as Product Owners, along with Mark from FNZ, a Financial Tech company that have recruited Makers Academy graduates previously. 

The Craftathon made me think a lot about my processes when coding, either for work or pleasure. There were three points that I took with me from the day: 

Do what needs to be done

Where do you start when starting a new project? This is one of the trickiest things to decide upon when you have finished wire framing. The Craftathon reminded me that the best place to start is with what is most important to your app. 

What made me realise this was that the team I was working with decided to start by creating the log in for the administrative back end of the website. This, you could argue, would make common linear sense, as to log in would be the first thing you would be required to do as an administrator. However, with minimal time, as a Product Owner, I was not interested in the team developing a log in for me, I wanted to see how many tickets to the moon had been sold. I advised the team this should be the first thing they do. 

In a recent app I am developing as a side project, I changed my plan for the next model I was going to add, using this same reasoning. 

Create your code ‘properly’

By the end of the day, I was impressed with how all of the teams had created workable apps with some marvellous css in less than 6 hours. A couple of apps, however, crashed when they were demoed. It happens, particularly in the fast paced world of a Hackathon. This, however, was a Craftathon. 

As one judge pointed out ‘even if you had just created an app that takes a booking from a customer and displays it to the product owner, that is fully tested and working, you would be ahead of the game. Hacking is great fun, and it is always better to get good working code quickly than labour over perfect code (this is what refactoring is for), however using the correct processes (what I mean by ‘properly’) to create robust code will make your life easier as your app develops. 

Even if it is just for fun, there’s nothing wrong with getting into good habits, such as unit and feature testing and committing to GitHub regularly.     

Listen

Whether you are working on a project for yourself or someone else, it is always important to listen and understand what is required, so you can ensure that you can create in as simple fashion as possible. 

When working on your own, this could be considered planning, however by listening to yourself or someone you are working for will always create questions and these questions will help solidify your understanding of what is actually required to make a project a success.

The Craftathon was a lot of fun, and I would like to thank Makers Academy for taking part. It was nice to catch up with everyone there again. Below are some more pictures from the day...

Ella and I with our serious Product Owner faces on

Ella helping the Craftathon participants relax

My first post mentioned DNS as one of the many initialisms I had picked up working on my first full week as a developer. I wanted to write more about DNS, as we were recently required to migrate some of our sites on Heroku, from CEDAR-10 to CEDAR-14. One of the sites could be accessed via many addresses, and we needed to make sure that this was still the case after we performed the migration. 

There is a glossary of DNS record types available on Wikipedia, which is well worth taking a look at. In this blog post though, I would like to go into more depth on AAAA and CNAME record types.

AAAA refers to the domain name your IP address will speak to (read my first blog post for more information on IP addresses). If you are using Heroku, this will typically be the name of your heroku app itself (i.e. my-app.herokuapp.com). You can find out more information on customising domain names for Heroku here.

CNAME is how you would refer to other web addresses for your app. You would always point these in the direction of your AAAA name, which would direct them to the IP address. You cannot link directly from a CNAME to an IP address. Below are some examples: 

CNAME myapp.com > my-app.herokuapp.com

CNAME myapplication.co.uk > my-app.herokuapp.com

I found some notes I made a while ago on rebasing so thought it was worth adding to the blog, as it’s a handy command to master.  This link contains an in depth description of what git rebase does  and how it differs from the git merge command. I won’t go into any more detail about that, as the tutorial in the link explains it well. However I have included some git rebase commands that I use regularly:

- When in a feature branch that is behind origin master: git rebase origin/master

- When you are in a feature branch and want to incorporate changes from another branch you are working on (i.e. branch x) with all changes up to date locally: git rebase x

- When you are in a feature branch and want to incorporate changes from another branch someone else is working on (i.e. branch x) and local branch is behind the git repository: git rebase origin/x

- When you want to push said feature branch: git push -f (n.b. be careful of using this command. What you are doing here is force pushing which, if not used properly, can lead you to push some things that you don’t want to.)

I must have blacked out during the databases lecture at Makers Academy as, when working on our Bookmark Manager project, created in Sinatra and our first exposure to relational databases, it felt that my fellow cohorts were happily whizzing around their databases, using the ‘psql’ command in the terminal, whilst I was left scratching my head in confusion. 

Databases have always been bit of an elephant in the room for me since me since then, I could do enough to get by but was embarrassingly aware of my ignorance, When the time came for me to learn them and I threw myself into this challenge whole heartedly. 

Once you have installed postgres  and are up and running the commands are pretty straight forward.  I found this really great tutorial that takes you though the commands that is well worth taking a look at. To get you started though, below are a few key sql commands that allow you to retrieve information from a psql database: 

SELECT - How all retrieval commands will begin. This will be typically followed by the thing you wish to select. 

*  or ‘a, b, c’ - Typing * after SELECT allows you to retrieve all columns. If you want to retrieve specific columns, you can do so by typing the column names in brackets after SELECT. (i.e. SELECT a, b, c will retrieve columns with the names a, b, and c. 

FROM - You have stated that you want to retrieve something with select. FROM is the command that specifies that table that you want to retrieve the selected information from. 

WHERE - If you want to make your selection more specific, you can use WHERE, for example, if you wanted to select all column items from a table that were entered after 1st January, you would SELECT x from y WHERE date > 01/01/2015;.

Here’s a program I made that allows you to enter people’s names and then shuffle them to randomly pick them out. Perfect for charades! You can run this from your console by typing the following

- irb  

-  require ‘./shufflr.rb’

- Shufflr.run_shufflr

I tried to keep this as DRY as possible. It’s on GitHub so make improvements if you wish. It’s just a short, fun program but helped pass a couple of hours whilst on holiday. I learned a lot too. The ‘sleep’ method helped make it feel more alive, and the ‘foo.times’ method helped dry it up a little.

When I first heard of a ternary operator, I thought i was some sort of contraption from the Industrial Revolution (I also thought a hash rocket was a sex toy, but more about that another time). 

A ternary operator, is no Spinning Jenny though. It is a succinct way of writing conditional statements. Conditional statements are like forks in a road. If the code chooses one path, something will happen. If it chooses another path, a different thing will happen. For example, consider the following statement: 

If we have more than £20, we can have the three course set menu. If we have less than £20 we can have the two course set menu. 

In Ruby, this statement would be represented like this: 

A ternary operator does the same thing, but rather than using ‘if’ and else’, it uses the ‘?’ and ‘:’ symbols. The ‘?’ goes after the condition ( If we have more than £20) then follows the statement that the condition returns true for (We can have the three course set menu). The ‘:’ separates the true and false statements, which means the false statement completes the command (We can have the two course set menu). Here it is in Ruby: 

Working on ruby on rails projects mean that you will spend a lot of your time inserting and manipulating strings and symbols in your code. Both strings and symbols represent messages and those messages will be passed within your program to make it work, however they are very different.

A string is typically used to create pieces of text that can be used in your program. It will be one of the first things you learn when learning to code.

Symbols will come a little later in most people’s Ruby learnings, and are slightly harder to understand. Strings are lines to text. Simple. Integers are numbers. That’s straightforward. Floats are decimalised numbers. Easy. Symbols?

If everything in Ruby is an object, a symbol is one instance of an object. When you create a symbol, you are creating an object with a definitive value.

Below is an example of the difference between a string and a symbol. I created a string called ‘hi’ and a symbol called ‘:hi’. I then requested their object id:

...and then I did the exact same thing again:

Notice the string id’s on lines 2 and 6. Then notice the id’s on lines 4 and 8. The string has different id’s where the symbol has the same id. I typed exactly the same thing twice, in both instances of string and symbol. Why has the symbol’s id remained the same and the string’s changed?

An easy explanation would be that the id of identical strings will always be different. You can have as many ‘hi’ strings as you wish in your code and each of them will be unique.

My brain sometimes lies to me. I don’t know why it does this. I don’t know how it can benefit for misleading me, however it seems to enjoy it. It gives me information that, despite being received correctly initially, is passed to me from my brain in the opposite fashion. This seems to happen most when I am directing people. My hand may point left, however the word ‘right!’ will fly out of my mouth, before I even get a chance to stop it. 

Perhaps my brain has a cruel sense of humour. Maybe it enjoys to see me ridiculed. I cannot be sure. The fact of the matter is though, my grey matter tells me fibs.  

Thankfully, it has been kind to me, when it has come to my learning to code. I have fed it information, over the last few months, the way a foie gras producer feeds a goose. My brain seems to have enjoyed this gorging, and it even seems, like a marathon runner ingesting vast amounts of calories before a big race, has seemed to become sharper with a belly full of knowledge. It still likes to play tricks on me though.  

One area that is has decided me to fool me, time and time again, is with variables. Variables can either be of the local, instance, class or global variety, and the reasons they are named as such is pretty obvious. My brain, however, still likes to switch the variable name and the function around, which means I do not convey what I want and generally sound like a wally. 

This post intends to, once and for all, make sure I know which variables do what, so I can get one over on my brain. 

Let’s start though by stating the purpose of variables.

Variables hold information so that it can be used later in a program. If we had the simple equation: 

z = x + y

x and y would be our variables. The values of x and y can change, however the output z would always be equal to x added to y. For example: 

If x = 1 and y = 1… z = 2

If x =  2 and y = 2… z = 4

The values of x, y and z can vary. What won’t vary though is the fact that z is the same as x added to y. 

Now we know that, lets look at the differences between each of the four types of variables:

Local variables occur within limited parameters. this is why they are local. You would use these within a method, for example, to hold onto a value that you wish to use elsewhere. In Ruby, local variables are typically lower case. If they are more than one word, each word is seperated by an underscore.

Instance variables are used in classes and represent an instance of the class you have created, in other words, the object. If you ran a record shop and wanted an app to manage stock, you would create a album class. This class could have two instance variables; name and price. All albums in stock would be within the album class, however each album (each obeject, in programmer speak) would have a different name and net price. In Ruby, instance variables have an @ sign before them i.e. @name and @net_price.

Class variables are broader than instance variables. Each object of the class does not have its own copy of a class variable. Instead, every object shares the one and only copy of that class variable – and any changes made to that copy are seen by all of the objects of that class. Using our record shop analogy, all albums would be have 20% VAT added to their net price. If the governent changed VAT from 20% to 17.5%, you would change the class variable to 17.5%. in Ruby, class variables are recognisable as they are preceded with @@, however, as Ruby is an object oriented language, class variables are rare.

Hidden inputs are a clever way for users to inadvertently communicate with a form. We created a universal search function and, when this was being used within a navbar for example, wanted to ensure that the form would return results across three different results criteria; ‘Invoice’, ‘Order No’ and ‘Quote’.  

By using Hidden=“Quote” et al, it allowed us to check each of these boxes within the universal search page on behalf of our users, so the form displayed those results when the user was redirected to the universal search page. 

The user could then refine their results as they wished, once they were within that page.

It did this by including hidden elements within the URL path. 

This tutorial gives a good explaination http://www.echoecho.com/htmlforms07.htm 

Everyone loves a good initialism. It doesn’t matter if you work for the CIA or the BBC, have a PHD or no GCSE’s, whether you are an LO or an OAP. In most work environments, these are used by people to sound clever and busy. Programming has tons of initialism’s however these are because they are created by clever, busy people. 

I learned three new initialisms this week. They aren’t really connected, however I am grouping them together in this post as it is a chronological knowledge bank of my life as a professional developer. In time, this post will embarrass me and I will move the contents into a better structure. However for now, please excuse my ignorance. 

- DNS = Domain Name System: The internet uses the DNS to associate domain names (for humans) with IP addresses (for computers). i.e. www.tumblr.com has an IP address of 66.6.41.30. I found this out as a website I was working on had a relevant domain name that was not associated with the correct IP address. 

- CDN = Content Delivery Network: CDN’s copy your asset pipeline onto a variety of servers across the globe. This has two benefits; 1. It means your page can load faster and 2. it means If there is any errors with your source, your assets can be served elsewhere. We needed to create a new CDN for a client we worked with, as the people who developed their website initially had not passed over control of it. 

- ERD = Entity Relationship Diagram: With all relationship databases, the ERD allows you to see the how tables within your database relate to each other. You will see the term ‘has many’ used a lot in rails. This demonstrates how relationships interact. For example, a mother can have many daughters, but a daughter can only have one birth mother.