DEV Community: Saral Karki

Comparing Sandeep Lamichhane’s Twenty 20 stats with other prominent leggies

Saral Karki — Mon, 08 Jul 2019 08:34:43 +0000

Surely the name “Sandeep Lamichhane” needs no introduction. He has been making waves in the Twenty 20 cricketing world by delivering outstanding performances in the IPL, Big Bash and other international T20 leagues. However, I wanted to take a look at how exactly Sandeep has been faring compared with some other legendary leg-spinners and his contemporaries.

Play around with the dashboard

All of the data were collected from Cricinfo.com and after meticulous cleaning of the data, here are the findings. The bowlers in the list are : Shane Warne, Anil Kumble, Rashid Khan, Yuzvendra Chahal, Amit Mishra, Imran Tahir, Adam Zampa, Adil Rashid, Rashid Khan and Sandeep Lamichhane.

Matches played:

Total number of matches played

Sandeep is relatively very new to the realm of T20 leagues and comparatively has played much fewer games compared to others. Anil Kumble and Shane Warne are the only two former players in the list, but even they have played more than Sandeep. Sandeep is likely to catch up to these two legends though.

Some of the key indicators to judge a bowlers ability in T20 cricket are the

Economy rate: The average number of runs conceded per over in cricket.
Bowling Strike rate: Measurement of a bowler’s average number of balls bowled for every wicket taken.
Average: is the number of runs they have conceded per wicket taken.

However, it is widely recognized that such statistics have severe limitations in assessing the true abilities of a player’s performance [1]. Therefore, we will be looking at the measure called Combined Bowling Rate(CBR) as developed by Lemmer. [2] CBR was constructed by using the harmonic mean of A, E and S. For calculation purposes it can be written as:[3]

CBR Formula

One of the limitation we would be facing was the variable value if the number of overs bowled were small. However, in our case all the bowlers have bowled enough overs and we likely need not worry about the few overs limitations.

Total number of overs bowled

Using the CBR we can get a good overview of Sandeep’s performance.

CBR Vs Economy:

CBR vs Economy rate

We can observe that based on economy Sandeep is fourth on the list. However, if we take a look at the CBR which according to the earlier cited works is a better measure for performance, we can see that Sandeep jumps to the third position only behind Rashid Khan, and Imran Tahir.

Judging by both the CBR score and the economy rate we can see that Sandeep has been successful in his short stint as a T20 bowler.

Surprise finding: It was rather interesting to see Shane Warne go to the bottom of this list. A case can be made for him though: the champion spinner was in the latter part of his career and therefore wasn’t at his supreme best.

For the full code

—
References:

Lewis, A. J. Towards fairer measures of player performance in one-day cricket. _Journal of the Operational Research Society._2005, 56 : 804–815.
Lemmer, H. H. The combined bowling rate as a measure of bowling performance in cricket. South African Journal for Research in Sport, Physical Education and Recreation. 2002, 24 (2): 37–44.
Lemmer, H. H, Perspectives on the use of the Combined Bowling Rate in Cricket. International Journal of Sports Science & Coaching Volume 9 · Number 3 · 2014, 513–523
Bhattacharjee D, Pahinkar D. G, Analysis of Performance of Bowlers using Combined Bowling Rate, International Journal of Sports Science and Engineering Vol. 06 (2012) №03, pp. 184–192

Nepal Earthquakes Magnitude Data Analysis and Data Visualization with Python

Saral Karki — Wed, 15 May 2019 09:30:30 +0000

This paper attempts to analyze and visualize the earthquake data of Nepal ranging from 1994–2019. The data was extracted from the National Seismological Centre (NSC) database. The code run to fetch and clean the data can be found here.

Where did the data require cleaning?

Once the data was scraped from the webpage it required a bit of cleaning. Most of how the cleaning was done has been described with comments in the code, however few things I was required to do were:

i. Change the date to a proper format:

The dates in the database were not in the standard DateTime format. The Nepali and the English dates were concatenated together. So the first task was to change the dates to a proper format.

ii. Changing the time to a proper format:

The time column in the database was not in a standard format. Therefore, this too required changing.

Once these two tasks were completed, my database was more or less ready for quick analysis and visualization.

iii. Dropped rows:

One of my precondition for this analysis was that the Epicenter had to be inside Nepal. Therefore, I dropped off any row where the Epicenter was countries other than Nepal.

Finally, there were a few coordinates where there were errors in latitudes and longitudes. Once those were accounted for and cleaned the data was ready to be used.

Data analysis

The first step of the analysis was to import the required libraries.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
plt.style.use('seaborn-pastel')

With the library ready, next up was importing the data file.

df = pd.read_csv('earthquake.csv')

I was able to import the required CSV file pandas ‘read_csv’ function. I quickly viewed the contents of the data frame now conveniently called df.

df.head()
df.describe()

df.head( )

df.describe( )

This gave me a quick overview of what the data looked like and a quick summary stats for the numerical data.

A quick glance at the summary statistics showed that there have been 933 earthquakes in Nepal since 1994. It has been stated that “More than 30,000 tremors”were felt in 2015 alone after the massive earthquake. However, it must be noted that NSC processes the data of significant earthquakes and aftershocks.

Earthquake Magnitude Plot

plt.figure(figsize=(10,10))

sns.scatterplot(y="Magnitude", x=df.Magnitude.index , data=df)

plt.annotate('Gorkha,2015', xy=(389, 7.5), xytext=(385, 7.25),arrowprops=dict(facecolor='black', shrink=0.01),)

plt.annotate('Gorkha,2015', xy=(390, 6.5), xytext=(350, 6.0),arrowprops=dict(facecolor='black', shrink=0.01),)

plt.annotate('Dolkha, 2015', xy=(443, 6.84), xytext=(445, 6.3),arrowprops=dict(facecolor='black', shrink=0.01),)

plt.annotate('Dolkha, 2015', xy=(540, 6.74), xytext=(541, 6.5),arrowprops=dict(facecolor='black', shrink=0.01),)

plt.annotate('Taplejung-Sikkim border, 2011', xy=(282, 6.74), xytext=(100, 6.6),arrowprops=dict(facecolor='black', shrink=0.01),)

plt.savefig('overall\_earthquakes.png')

Plotting every earthquake since 1994 to 2019

We can observe from the scatter plot there have been some massive earthquakes especially four massive ones in 2015 alone.

Plotting frequency by Magnitude of Earthquake (1994–2019)

Yearly Earthquakes from 1994–2019

It can be observed from the graph the surge of frequency in earthquakes in 2015. The number of earthquakes has gone down and is following the pattern prior to 2015.

Yearly earthquakes from 1994–2019

Earthquake Magnitude Classes

Earthquakes are also classified in categories ranging from minor to great, depending on their magnitude. (Source)

ClassMagnitude

Great: 8 or more
Major: 7–7.9
Strong: 6–6.9
Moderate: 5–5.9
Light: 4–4.9
Minor: 3 -3.9

#array for storing the size\_class
size\_class = []

for magnitude in df.Magnitude:
    if magnitude >= 3.0 and magnitude <=3.9:
        size\_class.append("Minor")
    elif magnitude >=4.0 and magnitude <=4.9:
        size\_class.append("Light")
    elif magnitude >=5.0 and magnitude <=5.9:
        size\_class.append("Moderate")
    elif magnitude >=6.0 and magnitude <=6.9:
        size\_class.append("Strong")
    elif magnitude >=7.0 and magnitude <=7.9:
        size\_class.append("Major")
    else:
        size\_class.append("Great")

#Creating a column in the dataframe called size\_class
df['size\_class'] = size\_class

df\_size\_class = pd.DataFrame(df.size\_class.groupby(df.size\_class).count())

With this done, I had a column in the data showing the various magnitude classes. Plotting these

Earthquakes group by the magnitude class. (1994–2019)

Mapping the Earthquake on a geographical map

A new column was created in the database based on the earthquake’s magnitude and its estimated effect.[Source]. Based on magnitude affect the earthquakes were plotted in a map of Nepal.

scale = []
for magnitude in df.Magnitude:
    if magnitude >= 3.0 and magnitude <=3.9:
        scale.append("Limited Damage")
    elif magnitude >=4.0 and magnitude <=4.9:
        scale.append("Minor Damage")
    elif magnitude >=5.0 and magnitude <=5.9:
        scale.append("Slight Damage")
    elif magnitude >=6.0 and magnitude <=6.9:
        scale.append("Severe Damage")
    elif magnitude >=7.0 and magnitude <=7.9:
        scale.append("Serious Damage")
    else:
        scale.append("Great Damage")
df['scale'] = scale

Mapping the earthquakes based on damages

Finally, the Jupyter notebook for the entire code can be found here.

Visualizing desired steps distribution — using the central limit theorem

Saral Karki — Mon, 15 Apr 2019 08:08:31 +0000

Visualizing desired steps distribution — using the central limit theorem

Last week when I took a look at my steps data I noticed that the data was very spread out.

Showing the spread in the steps data

Though I felt relatively satisfied with the average steps I was running in a day, the data was too spread out — i.e. Standard Deviation(σ) was 3435.38. This suggested that 68% of the steps data was in between 7305.65 and 14177.25 steps. I had even got days where the total number of steps were well below 5000, and therefore I wanted to get my data to mimic a distribution where the standard deviation would be lower meaning that the steps data would not be as spread out as it currently is.

As suggested by the central limit theorem, I decided to take 5(N = 5) independent random samples from the steps dataset. I would repeat this process 5 times (iter = 5), to begin with, therefore giving me a 5 dataset with 5 independent random samples in each set. Next, I would find the mean of each 5 independent random datasets, and finally, I would find out the mean of means. I would then run the same experiment two more times, but this time increasing random samples to 20 (N = 20) and then to 100 (N = 100)

Defining the Functions

def random_steps_array(name_of_array, n , iterations):
    for i in range(iterations): 
        name_of_array.append(df.steps.sample(n, random_state = i,   
                              replace = True))

def sample_means(name_of_array, sample_mean):
    for i in range(len(name_of_array)):     
        sample_mean.append(name_of_array[i].mean())

The random_steps_array function would handle the random sampling and the iterations, and the sample_means array would take mean of the random samples.

Experimenting with 5 iterations where N = 5, 20,100

i. At N = 5

array_5 = []
mean_array\_5 = []
random_steps_array(array_5, 5, 5)
sample_means(array_5, mean_array_5 )

The random samples of 5 independent random variables were stored in the array_5 means of the random variables were stored in mean_array_5

Sample distribution of the sample means at N=5

With only five iterations of 5 independent random samples, the mean of sample means was a bit further away from the actual mean of 10741.45. However, the taken the distribution was now less spread out and the standard error of the mean or (a.k.a. the standard deviation of the sampling distribution of the sample means — (S.E) was 1650.

ii. At N = 20

The mean of the sample means was much closer to the actual mean when I ran 20 iterations for a random sample size of 5 elements.

Sample distribution of the sample means at N=20

Already when the number of iterations increased I have a larger set of random samples. Thus giving me a mean that was getting closer to my actual mean, and the standard error of the mean (SE) was down to 561.72. Ideally, this is the kind of visualization I would like to have of my dataset where the data is not very spread out.

iii. At N = 100

Finally, at N = 100 the graph was even less spread out with the standard error of the mean (SE) at 259.27.

Sample distribution of the sample means at N=100

The spread was almost similar to at what the dataset was doing at 20 iterations, but the mean of sample means(10838.78) was much closer to the actual mean of 10741.45.

With the following experiment, I was thus able to visualize my desired graph, also I got some working knowledge with the central limit theorem.

Have I been covering enough ground?

Saral Karki — Wed, 10 Apr 2019 10:02:34 +0000

My goal is to get a minimum of 10000 steps per day. The 10,000 steps per day add roughly up to5 miles, and which is about 30 minutes of daily exercise. The Center for Disease Control and Prevention(CDC) recommend that adults get at least 150 minutes of moderate-intensity aerobic physical activity each week. Therefore, the 10,000 steps per day sorta satisfy CDC’s recommendation. My goal was to see if I was getting the recommended amount of exercise done on a daily basis.

I have been collecting my steps data with Garmin Forerunner235, and I was able to download the raw data using this code base Garmin DB. I sample data ranged from October 31st 2018 to March 31st 2019. Luckily, the data was relatively clean, and the cleaning process did not consume much of my time.

However, since I only needed the steps data, I took a subset of the entire data so that I got the required steps data ranging from the period aforementioned. In total, I had 153 samples but had to drop the first row since it was the day I got the tracker and no data was recorded on the day.

Decent average

The average number of steps taken

On an average over the course of the past 152 days, I average around 10,741 steps per day. The average did please me as it clearly showed that I was at least getting over 10000 steps per day. However, what clearly concerned me was the data well below the 10000 steps per day. How much proportion was below the 10000 steps?

Percentage of Steps taken from Oct 31st to March 31 2019

Over a period of 152 days, I was running more than 10000 steps 62.5% of the times, while I failed to do so 37.5% of the times.

However, there were some massive outliers on both sides of the region that was skewing my mean by around 200 steps.

Box Plot showing outliers in the data

What was a bit heartening to see that most of my data, if I did not take into account the outliers, fell between the 12500 to around 9000 regions.

Histogram with median

Furthermore, I wanted to look at the probability of me being able to do more than 10000 steps in any given day.

The probability of me getting over 10000 on any given day

I standardized the curve and using the z-table found out that there was a 59% chance of me getting more than 10000 steps on any given day. While I will take this, I intend to get that proportion higher at about 82%.

Finally, I wanted to take a look at the pattern and if there was a streak where I managed to get over 10000 steps.

HeatMap showing the streak of steps > 10000 or < 10000

Above in red are the days where I managed to get more than 10000 steps or less than 10000 steps. My longest streak for getting more than 10000 steps was 15 days and I managed it twice both in 2019. Once from the 9th of January to the 23rd of January. My streak was broken on the 24th, however, I managed to get back on track and start another 15 days streak from the 25th to 8th February. My streak for lesser than 10000 steps a day has also come twice and the streak has been for 8 days. The first one came way back from November 2 to 9, and the second one came from March 16th to 23.

All in all, looking at the data I feel I have not done as well as I thought I had. I expected to have done more than 10000 steps for at least 80% of the times, however, the data suggests otherwise. The bright side, equipped with this data I can look forward to the future and get my probability proportion to somewhere close to 80%.

This is my blog

Saral Karki — Sun, 17 Mar 2019 12:16:13 +0000

Finally, after weeks of learning and working on the personal blog, I can say it has now taken a shape that I am satisfied with. There is still a lot of work needed to be done especially with the styling of the blog, however, overall I think I have got the features I wanted to add. So what features are integrated within my personal blog

User Authentication:
For user authentication, I used the 'bcrypt' gem. Though in my other projects I have used the 'Devise gem', this being my project, I chose to use bcrypt. Also, user authentication wasn't a feature that I absolutely required in this project, because it is a personal blog, and I am guessing the only person uploading here will be me.
Here's how I went about getting bcrypt to work on the blog.
Markdown:
For my blog I wanted to be able to enter the text as I do on Dev. Therefore, I went about finding how I could implement markdown on the blog. Also, I have no idea a thing called 'Rich text editor' existed. Had I known this, I would probably have gone and tried using a rich text editor instead. My ignorance was a blessing in disguise as now I am equipped with knowledge on how to implement both markdown and rich text editor.
Here is how I implemented the markdown
Bootstrap and Font-awesome:
Next up, I wanted to use bootstrap and for this, I followed the instructions provided on the bootstrap gem homepage. I also used the font-awesome icons to style the icons. Again, the Font-awesome gem page came in handy whilst implementing the FA icons.
Pagination:
For pagination I used the will_paginate gem. Here's my implementation of the gem on the blog.
Paperclip:
Finally, for adding images to the blog posts I used the paperclip gem. I was able to get the gem working on localhost, however, I soon encountered an issue on Heroku. The images looked to be stored on my database but every time I refreshed the images would disappear. It was then that I learnt, that Heroku wouldn't store my images, and therefore I would have to store my images elsewhere. The recommended platform was AWS.

Now I embark on my next goal to get the images on AWS.

Javascript! Here I come

Saral Karki — Tue, 26 Feb 2019 15:45:22 +0000

I am scared of javascript. There you go I said it. For some reason, I have been scared of JS and have been completely avoiding it. But, as we are all aware 'Javascript is everywhere", and if I wanted to become a developer, I would need to at some point in time face that fear and learn it.

Now, was the time to learn it, to devote time my time and really learn javascript. After scouring through various posts on JS, I decided to first try my hands on vanilla JS. No frameworks, for now, I want to really learn pure JS and no matter how tough it gets, I am going to do this.

For this week, I concentrated on this app

The code at [https://github.com/Saralkarki/keyboard/]

Under the hood of a scaffold generated controller

Saral Karki — Mon, 25 Feb 2019 16:23:50 +0000

This week, I have been working on a Todo list app, and for the first time, I used the rails scaffold. This generated a whole host of the required files, routes and codes. I really wanted to understand what was going on in the controller that the scaffold had generated, and so I started reading between the lines and tried unravelling the Rails magic.

First off was the index method in the todo_list controller that had been generated.

def index
 @todo_list = TodoList.all
end

This I thought was straight forward to understand having already completed a project in rails. The entire TodoList model that had been created would get stored in the @todo_list instance. This was a global instance denoted by the@ symbol, which meant I would be able to access the contents from the views as well.

I then opened up my rails console via rails c. Here I wanted to test a few things out for myself. Rails console is a good place to experiment and see what certain syntaxes are actually doing. Upon running the TodoList.all in the console, my understanding of the .all method was verified.

I wanted to see what would happen if I tried to figure out the class of the @todo_list. For this, in my rails console, I ran

@todo_list = TodoList.all
@todo_list.class

The output I received for class type was TodoList::ActiveRecord_Relation.. When working with the model, I have seen this class type many times. There's a lot for me to understand about the ActiveRecord_Relation class, but my basic understanding,I interpreted as:

Looks like activeRecord_Relation as I see in Rails console, stores the data in an array. In my case, something like this

#<ActiveRecord::Relation [#<TodoList id: 1, title: "New todo", description: "Hello this is the first todo", created_at: "2019-02-21 04:51:53", updated_at: "2019-02-21 04:51:53">, 
#<TodoList id: 2, title: "Todo #2", description: "Hello", created_at: "2019-02-21 05:28:20", updated_at: "2019-02-21 05:28:20">]>

Since, the acitveRecord_Relation is an array, I can iterate over it, and display the contents which is exactly what is done in the views. Also, it meant, I could access the elements in the array via indexing. This is exactly what I tried to do next to validate my claim in the console.

TodoList.all[1]
TodoList.all[1].created_at
TodoList.find(1).created_at

I was able to access the second element of the TodoList model with the first syntax. With the second, I was able to look at the created_at time column of the second data. Finally, with the third syntax, I was able to look at the column of the data whose id was 1.

Tip: See the difference between the indexing and using find method which uses id.

There's a lot more to activeRecord_Relation I am sure. My minuscule understanding of it, however, allowed me a glimpse into it. Hopefully, in the future there will be a post on acitveRecord_Relation itself as I understand it better.

Next, I looked at the create method that the scaffold had generated. Something was very intriguing here

def create
    @todo_list = TodoList.new(todo_list_params)

    respond_to do |format|
      if @todo_list.save
        format.html { redirect_to @todo_list, notice: 'Todo list was successfully created.' }
        format.json { render :show, status: :created, location: @todo_list }
      else
        format.html { render :new }
        format.json { render json: @todo_list.errors, status: :unprocessable_entity }

      end
    end
  end

What was intriguing to me was the new method being called at times, and other times I had seen the use of the create method to add entries to the model. My question was "If two method behaved the same way what was the difference between the two?"

I found my answer here.

I then went to the rails console to experiment a bit with the create and new method.

TodoList.new id:4 , title:"Todo 3", description:"What is up?"

This syntax worked and I got no error, however, the data would not be written inside the model. What was happening was using the new method merely instantiated but did not save to the database. In order to save to database, we needed to use the save method in tandem with the new

test = TodoList.new id:4 , title:"Todo 3", description:"What is up?”
test.save

This saved the contents of test into the model TodoList. When we think about it, the new and the save method together work similarly to the create method. However, as described by the stackoverflow answer.

The part of the answer that made some sense to me was

Although it is correct that create calls new and then save there is a big difference between the two alternatives in their return values.
Save returns either true or false depending on whether the object was saved successfully to the database or not. Create will return the model regardless of whether the object was saved or not. This has implications for the code above in that the top branch of the if statement will always be executed even if the object fails validations and is not saved.If you use create with branching logic you are at risk of silent failures which is not the case if you use new + save.

Finally, a new feature introduced to me was the respond_to block. This block allowed me to render my data elements in either standard html format or a json format. For quick verification, in my browser, I entered the .json at the end of my url (localhost:3000/todo_lists/27.json) and got a rendered version of the data in json.

For now, I don't know what to do with this information. What I do know is that json is an important element in web development. Why, and how I will find out as I go along in my coding journey.

My first rails scaffold

Saral Karki — Thu, 21 Feb 2019 15:26:48 +0000

I finished my first app last week. This app basically is my personal blog. I hope to maintain and add features to it in the days to come. Today though, I started with a new project - a todo list. The first thing I did for this project was rails g scaffold todo_list title:string description:text. And with it, I had used the scaffold for the first time. There was one thing I wanted to do though, I really wanted to understand how the scaffold worked.

Here's my understanding of how the scaffold works. Upon creating the new scaffold with the above command, it did a couple of things for me.

It generated the routes for me in the routes.rb file in the config folder. Viewing the routes.rb file in my editor, I could see resources :todo_list on the file.
It generated a model TodoList and once after migrating the database via 'rails db:migrate` the database was ready to be used. The model had a title and description because I had set those two parameters when creating the scaffold.
Scaffold also generated all the controllers for the CRUD methods. Meaning from the get-go I would be able to perform create, read, update and deletion of entries.
Finally, all the views were generated, and the views had a form with title and description. Also since the controllers had already defined the CRUD methods, I was able to create, delete, edit and see my entries.

It was that easy. My entire last week's work summarised by one syntax. 😵😵😵😵

Still, last week was a great learning experience for me building everything from scratch, and this week as I delve into the scaffold generated code, I will really read between the lines of codes and understand what it does.

Good job

Saral Karki — Wed, 20 Feb 2019 16:08:36 +0000

How important are those two words especially coming from someone whose opinion you value? It was vital for me today, those two words "Good job!" coming from a friend and a mentor.

I was having one of those days where I was getting rather overwhelmed today. With all the effort that I have been putting into learning programming, I was having that kind of a day where I was feeling incompetent. The question if I would ever get good enough was hovering and traumatizing me. I buzzed up my friend and asked if we could meet. My friend a software engineer by trade has been programming ever since I met him back when we were still kids. He had graciously offered to give some of his time to mentoring me whenever he could. There have been times when I have gone to him showed him my projects and he has helped me figure out concepts and given me coding tips. Never though had he said a good job or really given me the compliment of any kind. As a matter of fact, he has always pushed me and said there's a lot for you to learn mate, keep at it.

Today, however, when he said it, it felt like I had really achieved something. Funnily, when I think about it, this "good job" from him did not come because I had mastered some algorithm or learnt about some data structure. As a matter of fact, it came from what I thought was me solving a minute issue.

So I had been using the will_paginate gem the other day, and I had encountered an issue with the gem will_paginate_bootstrap. For some reason, the gem was not being applied to my HTML file. After reading the documentation on the homepage, I figured that since will_paginate_bootstrap gem was not being maintained it might not work with the latest Bootstrap 4, the version I had been using. So I opted to use the bootstrap_will_paginate gem instead, and it worked in an instant.

As I related this what I thought was a minor victory of mine, he said "Good Job". Furthermore, he added, "much of programming in rails is about being able to figure out what gems will work for you and what won't." Until then, I did not think that figuring out something like this even counted as programming, but apparently it did.

All of a sudden, I found this new vigour and if ever I needed a validation that I was doing well and I was learning - this was it.

Pagination done

Saral Karki — Mon, 18 Feb 2019 15:18:25 +0000

After a few days of much-needed break, it was time to get back to adding features to my blog project. Today's assignment was adding pagination to the blog posts. In order to get this feature working, I used the will_paginate gem. On the gem file, I added gem 'will_paginate', '~> 3.1', '>= 3.1.6', and ran a quick bundle install that install the required gem.

Then, it was all about following the documentation of the gem.

First, off I updated the posts controller for my index method.

 def index
  @post = Post.all.order('created_at DESC').paginate(:page => params[:page], :per_page => 3)
   end

As you can see the .paginate has been added, and I've followed the documentation. Also, I had set three articles to be shown per page.

Once this was done, the page updated itself to show only three articles on a page. Now I needed to add the pagination in the view itself so that the users can navigate on the website. For this, I used

<%= will_paginate @post %>

Once this was done, I got the pagination working with a navigation menu. However, I still needed to add a bit of style to the menu so that they looked good. For this, I could use bootstrap, something that I had already been using for my app.

I used the gem bootstrap_will_paginate for this via gem 'bootstrap-will_paginate', '~> 1.0'. Again, I ran bundle install, and finally on the views, I added the styling by following the documentation of the gem.

 <%= will_paginate(@post, :renderer =>
WillPaginate::ActionView::Bootstrap4LinkRenderer) %>

The pagination was now ready to be used.

Rails with Postgresql

Saral Karki — Thu, 14 Feb 2019 15:31:02 +0000

During the last project, it was only when I was deploying the app to heroku that I learnt that heroku supported postgresql. I then changed the database to postgresql from the default sqlite that rails came with.

For the project that I am embarking on, I decided to start off using postgresql to begin with.

I created the app the usual way rails new (appname), and then proceded to change the database detail. In the database.yml file I changed the default details to

default: &default
  adapter: postgresql
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  timeout: 5000

development:
  <<: *default
  database: app_development

test:
  <<: *default
  database: app_test

production:
  <<: *default
  database: app_production

I also added the gem pg to the gemfile and ran bundle install to install postgresql.

With this done, I ran rails db:create that created the database. I then created my users model. This time around I will be using the devise gem for the users authentication process. Finally, I ran rails db:migrate and my model was ready.

After all this was done, I found out that I could have skipped the process of changing the database.yml file had I mentioned the kind of database I would be using while generating my app with rails new app --database postgresql.

Did I learn something today? Yes, I did even though I did not get a lot of coding hours logged in today. I intend to start working with devise tomorrow, so I tomorrow's post will be all about getting started with the devise gem.

Ordering the blog posts

Saral Karki — Wed, 13 Feb 2019 15:51:54 +0000

I have to say now, I have come to the end of my first project of building a blog app with Rails. Whilst there are features that can be added to the site, my enthusiasm in this project is wearing off. Therefore, I intend to hold this project for the time being and move on to my next project idea starting tomorrow.

However, there was one more thing I wanted to implement before moving on to the next project. This feature was sorting the blog post by showing the newly created post on top. After having hacked through the solution, this one seemed pretty straightforward, and one line of changed code did the trick.

  def index        
        @post = Post.all.order('created_at DESC')
   end

In the post controllers function index, all I needed was to do was add the order method. The order method would look at the created_at column at sort order the posts in descending order.

With this done, I did also implement a feature that allows the user to press tab when typing inside the textbox while creating a new or editing a blog post.
I hacked my way through this and used vanilla Javascript for this.

var myInput = document.getElementById("textbox");
    if(myInput.addEventListener ) {
        myInput.addEventListener('keydown',this.keyHandler,false);
    } else if(myInput.attachEvent ) {
        myInput.attachEvent('onkeydown',this.keyHandler); 
    }
    function keyHandler(e) {
        var TABKEY = 9;
        if(e.keyCode == TABKEY) {
            this.value += "    ";
            if(e.preventDefault) {
                e.preventDefault();
            }
            return false;
        }
    }

I did for a little while encounter difficulty in getting the javascript included in Rails but was finally able to do it.

I included the main.js the js file I had created in the app > javascripts folder, and then on application.js in the app folder, I added the following lines //= require main. This I thought would work, but it did not. I got the following error in my browser console.

Uncaught TypeError: Cannot read property 'addEventListener' of null

I had to search for a solution and to be honest I haven't done a lot of javascript, so I could not really follow along. Something, that I did get was that the javascript addEventListener was running even before there was any text on the body textbox of my blog.

For a solution that is working currently for me, I copy pasted the following code

<%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>

at the end of the application.html.erb document.

With that, I was able to get the tab working on my textbox. I am yet to understand what my issue with javascript was? Or If I am including the js file correctly to my rails app?

All in all, it has been a great learning experience for me. However, I must move on from this app, and start fresh.