Blog

***Teaching philosophy:*** I truly learn the material more by teaching them to others than taking the class myself, so I approach my teaching more from a learning perspective. I approach my relationship with my tutees and students more like with my peers engaging intellectually with materials rather than a top-down approach. I am deeply committed to creating a safe, comfortable, and growth-based learning environment, and I am constantly looking for constructive feedback and updating my teaching pedagogy to achieve that goal.

##### [University of California, Davis](https://economics.ucdavis.edu/), CA, 2021-

*   Econ 001B, Principles of Macroeconomics (Fall 2021)

*   Econ 001A, Principles of Microeconomics (Winter 2022)

##### [Reed College](https://www.reed.edu/), Portland, OR 2017-21

*Roles as a Teacher Assistant (TA), tutor, grader, and Student Teaching Consultant (STC)*

###### *Economics Courses*

*   Econ 201, Introduction to Economics (Fall 2018)

*   Econ 313, Microeconomic Theory (Fall 2021)

*   Econ 314, Advanced Macroeconomic Theory (Spring 2021) 

*   Econ 340, International Macroeconomics (Fall 2020) 

*   Econ 343, Behavioral Finance (Spring 2020)

*   Econ 344, International Monetary Systems (Spring 2021)

*   Econ 383, International Trade (Fall 2020)

###### *Math/Statistics Courses*

*   Math 111, Calculus (Spring 2018-Fall 2021)

*   Math 112, Introduction to Analysis  (Fall 2018-Fall 2021)

*   Math 201, Linear Algebra  (Spring 2019-Fall 2021)

*   Math 202, Vector Calculus  (Fall 2020-Fall 2021)

*   Math 241, Data Science  (Spring 2020-Fall 2021)

*   Math 391, Probability Theory  (Fall 2021)

*   Math 392, Mathematical Statistics  (Spring 2021)


To get in touch please fill the form below.

name

email

subject

message

consent

Contact

I am an aspiring economist and an R developer working on the {shinymodels} package within the {tidymodels} package ecosystem.  I am originally from Nepal and I finished my undergraduate in mathematics and economics at [Reed College](https://www.reed.edu/), Portland OR in 2021.  Currently, I am a first year economics Phd student at the [University of California, Davis](https://www.ucdavis.edu/). My research interests include macroeconomics modeling, inequality, and data analysis.

If you like my posts, feel free to [buy me a coffee on Ko-fi](https://ko-fi.com/shishamadhikari)! ☕️


About

Home

This week, I started my internship as an R developer within the [{tidymodels}](https://www.tidymodels.org/) package ecosystem at[ RStudio](https://www.rstudio.com/). I will be working on {shinymodels}, a package that, given a tidymodels object, will launch a [Shiny](https://shiny.rstudio.com/) application. I am fairly new to the internship but the process of preparing, applying, and getting the internship has taught me some valuable lessons that I think might be helpful for fairly new coders like myself looking to apply for similar opportunities.

###### A brief backstory

A year ago, if someone had told me I would be interning for RStudio, I would have laughed at them. Spring of 2020, two weeks into my Data Science class, I remember having a full-throttle crying session in my school's cafeteria about my struggle and my steep learning curve with R; it was a little silly of me to be in the class that was solely based on R without having a good baseline R knowledge, but I was committed to it. I have to say, I got lucky, the professor for the class Prof. Kelly McConville was the most patient person to get me started with R; she taught me to be comfortable and enjoy the process of learning R, which has been a fun and ongoing process ever since. Between then and now, I have taken several classes like Mathematical Statistics, Statistical Learning, and Spatial Data Analysis that solely/heavily used R programming. Last summer, I also got to enhance my skills while working on [a group project](https://homes.cs.washington.edu/~domta/seattle-inequity.html) with Dominick Ta as a part of the [Public Policy and International Affairs program at Carnegie Mellon University.](https://www.heinz.cmu.edu/programs/junior-summer-institute/) Getting exposed to various uses of R and being able to use it to analyze/solve real-world problems is what got me more interested in the developing side of the language and hence my interest on this position. To be honest, {shinymodels} is a little more special: I have a vivid memory of truly enjoying programming in R only after I created my first app in Shiny, it was that moment for me. And, as a modeling enthusiast, I had been following tidymodels' development; this internship combining two of my favorite R packages, Shiny and tidymodels, to create {shinymodels} was something I was truly passionate about and wanted to work on. That is when I decided to apply for the job.

###### ![](/\_static/app-assets/images/meme.jpeg)

###### Tips for before and during the application process:

*   **To learn new code, apply it:** The best way I enhanced my coding skills in the past year was by working on projects and learning new code as I went on. While trying to learn R as a beginner, google was (still is) my best friend! I also extensively used other forums ([Stack Overflow](https://stackoverflow.com/),  [#rstats twitter](https://twitter.com/search?q=%23rstats\&src=typd), [community.rstudio.com](http://community.rstudio.com/), etc.)  that were pretty active and welcoming to get me started. Working in groups and learning from my groupmates helped a lot; closely observing some of the more experienced coders' workflows really helped me learn some valuable coding skills.
*   **Apply for the job:** It sounds silly but despite my relatively short experience, the fact that I even felt competent enough to apply for this job was the main reason why I got it. I realize I am not the most experienced coder out there, but I knew I had enough to get started with the position and I was ready to learn more. Had I let myself believe that I was not ready and I could not do it, I would not have even applied. Particularly from this application process, I learned that it's okay to feel intimidated and overwhelmed by the process but do not let that stop you from applying for the job you really want. I worked as a [peer career advisor (PCA)](https://www.reed.edu/beyond-reed/peer-career-advisors/index.html) for two years at my undergrad institution, and I was always told to encourage my advisees to apply for a job they are truly passionate about even if though they might be/feel slightly underqualified; you never know, you might be more qualified than how qualified you think you are.
*   **Format and review documents:** Make sure the core documents, your résumé/CV and cover letter, are both up-to-date, tailored, and in the standard formats. Have a career advisor or someone experienced review them before you submit.
*   **Talk to the people who know:** Both while learning R and applying for the internship, talking to and getting feedback from folks who had experience with what I wanted to do was a crucial step for me. For me, it was my Data Science professor [Prof. Kelly McConville](https://www.reed.edu/faculty-profiles/profiles/mcconville-kelly.html) and my friend [Simon Couch (a prior RStudio intern)](https://www.simonpcouch.com/). Getting their feedback and learning from them at all stages was a crucial part of my journey. So, I would highly recommend trying to find people who can do the same for you. I recommend [LinkedIn](https://www.linkedin.com/feed/) search to find relevant connections that you can reach out to (pro-tip: I'd start by reaching out to someone in your school's alumni directory or someone you have mutual connections with so that they are more likely to reply to your queries). Also, along the same lines, follow and closely observe the workflow of some experts (for me it was [Hadley Wickham](http://hadley.nz/)) in the field/language, it really helped me to learn about some best practices.
*   **Hyperlinks in cover letters:** When writing a standard one-page cover letter, it is hard to include everything, especially while explaining the relevant experiences. So usually, I add hyperlinks to my projects so that I can briefly explain a lot of relevant projects and the employers can easily click on the hyperlinks to access the relevant repos/folders to learn more about them. I did the same for the RStudio internship and I think it helped that my interviewers got to see my codes/projects before we talked.
*   **Be true to your story:** Getting this internship was probably the most humbling experience for me, not only due to my initial struggle with learning R but also with the fact that my supervisors believed in and gave a chance to my story. Going into the interview for the job, I was honest about my experiences thus far and my keen interest in getting better. I knew that I had a lot to learn but I also knew that I am a good learner and I thrive under growth-oriented mentorship. Throughout the application, I was open about my personal goal, intention, and approach to the job. Everybody's story is different and being true to one's unique story works often times than not.

###### During the internship

*   **Ask questions🤔:**  Now I have started the internship, at the end of each day, I make a list of questions that I can ask my supervisors. The list ranges from a highly technical question to something that might be as simple as the best practice to save my projects. I give myself a time limit, if I cannot get it within the time limit, I rather ask my supervisors who know more about the topic than trying to bang my head against the wall for several more hours. Especially for interns like myself, we are here to learn so ask as many questions as possible. Do at least some research to see if there are easily accessible solutions out there.

*   **Ask for clarifications🙇‍♀️:** Especially while attending big group meetings, not everything is going to make sense at first. I quickly realized that not knowing the keywords folks are using in the meetings can make me feel lost throughout the meeting, so now when I come across a repeating word that I have no clue about, I trying googling it or using the chat feature in zoom/slack or saving it to ask later; people are always nice enough to reply🤓

*   **Focus on learning stuff you wouldn't learn elsewhere👀:** One of the main things my boss told me during our first 1:1 meeting that has really stuck with me is that the goal for me in this job shouldn't be to just learn the technical skills to develop software but also to learn the thought process and collective brainstorming that goes into the process. Just after attending a couple of meetings, I am already beginning to understand the importance of skills like naming things right, creating documentation with just the right amount of information, figuring out the best way to deliver information, designing the most accessible templates, etc., which are the topics I used to underestimate during my developing process.

*   **Your ideas are equally valid💭:** I really care for this opportunity and I am an anxious person so it's hard not to overthink, but I try to remind myself that the fact that I am here means my ideas are equally valid. I am cautious when to speak up and occupy the space in meetings, but when presented with questions, I do not hesitate to contribute my ideas; my boss says, "it's always okay to ask why that way? Are there other ways of doing this? That's how we get challenged, learn, and grow."

In addition to the tips, I have to share my experience with the hiring process itself.  The application process for this job was the most efficient hiring process I have ever experienced. Just to give a brief idea: I applied on Wednesday (03/17), heard back on Thursday (03/18), interviewed on Friday (03/19), and got the acceptance on Monday (03/22). As a student employee who has spent weeks and months on the hiring process stressing and waiting to hear back from a job, I truly appreciated RStudio's efficient hiring process.

Hmm, let's see...I think that's all I can think of, for now. I will add/update this blog as I go on with the internship and more stuff comes up. Feel free to reach out with any questions/comments. This is my first blog, so wish me luck.

Thanks for reading🌻🌝🍃


Tips to apply for the RStudio Internship (or something similar)

Applying for the R Internship

[`Tidymodels`](https://www.tidymodels.org/) is the group of packages that allows modeling in R with a tidyverse-friendly interface. It is a commonly used package ecosystem for modeling in R, to learn more about using ['{tidymodels}'](https://github.com/tidymodels) for modeling, click [here](https://www.tidymodels.org/start/models/). In any kind of modeling, [resampling methods](https://www.tmwr.org/resampling.html), such as cross-validation or validation sets tuning parameters, and [model tuning tools](https://www.tmwr.org/tuning.html) are widely used to evaluate the modeling process and select effective models. Once models are created using resampling function like `tune::fit_resamples()` and tuning functions like `tune::tune_grid()` and `tune::tune_bayes()`, the goal is to measure the performance and variation in model results. To make this exploration of a `{tidymodels}` object easier and faster, we built [`{shinymodels}`](https://github.com/adhikars11/shinymodels).

##### {shiny} + {tidymodels} = {shinymodels}

As the name suggests, [`{shinymodels}`](https://github.com/adhikars11/shinymodels) is the package that allows exploring a [{tidymodels}](https://github.com/tidymodels) object in a [shiny](https://shiny.rstudio.com/) application. The goal is to visualize the results of resampling and tuning functions and compare the different models. Through various diagnostic plots, we hope to help identify structures and problematic observations that could otherwise go missing. Also, linking multiple graphics can lead to insight not revealed by a single view. With a model with tuning parameters, users can compare the models for different selections of the parameters.

Let's look at a simple example of how to use the package. Below is the code modeling `mtcars` with tuning parameters using [`tune_bayes()`](https://tune.tidymodels.org/reference/tune_bayes.html) function.

        ```{r}
        library(tidymodels)
        tidymodels_prefer()
        
        set.seed(6735)
        
        folds <- vfold_cv(mtcars, v = 5)
        car_rec <-
          recipe(mpg ~ ., data = mtcars) %>%
          step_normalize(all_predictors())
        svm_mod <-
          svm_rbf(cost = tune(), rbf_sigma = tune()) %>%
          set_engine("kernlab") %>%
          set_mode("regression")
        # Use a space-filling design with 7 points
        set.seed(3254)
        svm_res <-
          tune_bayes(
            svm_mod,
            car_rec,
            resamples = folds,
            initial = 7,
            iter = 3,
            control = control_bayes(save_pred = TRUE, verbose = TRUE)
          )
          ```

Here, the object svm_res is the `{tidymodels}` object of class `tune_results`. Now, you can use  `{shinymodels}` to explore the object in a shiny app. The launcher function in `{shinymodels}` is `explore()`.

        ```{r}
        library(shinymodels)
        explore(svm_res)
        ```

It should launch the following shiny app:

### ![](https://media.giphy.com/media/MJQBGHVZmGzFiMqWMs/giphy.gif)

As you can see, there are mainly two categories of tabs in the app:

*   **Tuning Parameters tab:** For models with tuning parameters (e.g., [`tune_bayes()`](https://tune.tidymodels.org/reference/tune_bayes.html)), the tab with tuning parameters consists of the data table for the tuning parameters and performance metrics for each candidate model. When the app is first launched, the *default configuration* is based on the optimal value of the first metric. Selecting a row in the tuning parameter table selects the related model which should then update the diagnostic plots in the plots tab(s).

*   **Plots tab (s):** The Plots tab consists of diagnostic plots to explore the model object. Clicking on a particular point or selecting a group of points in any plot should highlight the point(s) in all other plots. This will help see where an observation lies in different diagnostic plots and get insights about the observation. This will help diagnose the outliers or "problematic" observations in the modeling object and hopefully give insights on why that is the case. In the case of a model with tuning parameters, the plots tab displays the diagnostic plots for the selected model.

We hope that `{shinymodels}` will make it easy, fun, and efficient to explore a `{tidymodels}` object. Especially for users new to both the packages, we hope this package will remove the initial barrier to learn shiny applications in R to explore their modeling object in R.

This package was built by Shisham Adhikari (UC Davis) under the supervision of Max Kuhn (RStudio) and Julia Silge (RStudio) as a part of the RStudio summer internship 2021. Your suggestions, feedback, complaints, or compliments are highly valued and will guide us to improve the package continuously. Please email them to shishamadhikari6@gmail.com or max@rstudio.com or julia.silge@rstudio.com.

To give feedback, file a bug report, or ask a question, go to the [GitHub issues page](https://github.com/adhikars11/shinymodels/issues) or go to [RStudio Community](https://community.rstudio.com/) and create a post with the tag `tidymodels`.

For more information on {tidymodels}:

*   [`tidymodels.org`](https://www.tidymodels.org/)

*   [*Tidy Modeling with R*](https://www.tmwr.org/)


How to use {shinymodels}, the package I built this summer

shinymodels


As a part of the RStudio internship 2021, I wrote a package called [`{shinymodels}`](https://github.com/adhikars11/shinymodels), the package that allows you to explore a [`{tidymodels}`](https://github.com/tidymodels) object in a shiny application. The 12-weeks long internship under the supervision of Max Kuhn and Julia Silge was a great learning experience for me. I have used R for several of my classes and projects but the internship was an unique experience in that it really taught me the difference between running a script versus writing a package in R. As someone who started learning R fairly recently, I was both excited and nervous to spend this summer writing my own package. My day-to-day schedule was very much working on a particular workflow of building a function package in R. This blogpost is a step-by-step guide to that workflow to write a package in R using [devtools](https://www.r-project.org/nosvn/pandoc/devtools.html), [usethis](https://usethis.r-lib.org/), [roxygen2](https://roxygen2.r-lib.org/), and [Github Actions](https://github.com/r-lib/actions). 

#### Preparation 

##### Create a Github repository 

Create a version control repository for the package, I use github for this. If you are new to version control or Github, please read [this article](https://happygitwithr.com/) by Jenny Bryan. In my experience, *Happy Git and GitHub for the useR* is the must-do reading for anyone new to working on a project in R and Github. Long story short, a version control system like Github provides a home for our projects on the internet making it easy to share, collaborate, and reproduce any code.

![](https://media.giphy.com/media/bwjKWNSaWvNLj9t6k5/giphy.gif)

##### Clone the repository to your R server

Once you create a git repository, you can clone the project to your local server. 

![](https://media.giphy.com/media/Iy4mJbtzGsL4QJzHs4/giphy.gif)

#### Initiate the package 

First, install and load all the packages required for your package. 

        ```{r}
        install.packages(c("devtools", "roxygen2", "usethis"))
        library(devtools)
        library(roxygen2)
        library(usethis)
        ```
[Here](https://r-pkgs.org/workflows101.html?q=create_package#workflows101s) is an excellent reading about initiating a package. Now it's time to implement some magic of `usethis::use_*()` functions. In this example, we will be creating a package with tidyverse interface, so I will be using `usethis::create_tidy_package()` but feel free to use `usethis::create_package()`. Below is the code that uses usethis to set up a package.
        
        ```{r}
        library(usethis)
        
        setwd("~/cu") # replace 'cu' with the name of your package directory
        #initiate the package
        create_tidy_package("cu") #replace with the name of your package
       #add some files and package information
        use_description(
          list(
            `Authors@R` =
              'c(
                person(
                  given = "Shisham",
                  family = "Adhikari",
                  email = "shisham.adhikari@rstudio.com",
                  role = c("aut" "cre")
                  ),
            Title = "cu",
            Description = "Practice to make a pacakge"
          )
        )
        use_mit_license("GPL")
        use_code_of_conduct()
        use_spell_check()
        use_package("dplyr", "ggplot2")
        ```
#### Work on the package 

If you made this far, congratulations, you have the foundation for your package, now it is time to build up on that foundation. At this stage, your package folder would have three main files to know: 

* R: All your R codes go in the R/directory. You can either use a single .R file for all your functions or create a file for each function or group functions with similar purpose in a file. 

* DESCRIPTION: As the name suggests, this file is where all the important description, aka metadata of your package goes. I used Hadley Wickham's [chapter](https://r-pkgs.org/description.html) on package metadata to better understand what goes into DESCRIPTION. 

* NAMESPACE: This file contains all the information on imports and exports of your package that is exposed to the users. I have never edited this file by hand, devtools and roxygen2 will take care of it; make sure to add roxygen2 comments to your .R files and run `devtools::document()` to save the documentation to NAMESPACE. 

Now you know what to work on, let's get started with the actual work: functions, documentation, and tests. 

##### Functions

All your R codes for the package functions go to .R files in the R/ directory. I recommend using separate .R file for each function, you can even group the functions by their purpose. For example: let's add a function called `is_between()` that checks if a number is between the other two numbers, and let's save it to a file named R/is_between.R. 

        ```r{}
        is_divisible <- function(a, b, c) {
        # function to check if a is between b and c
        if (b <= a <= c) {
            print(paste(a,"is between", b, "and", c))
          }
         print(paste(a,"is not between", b, "and", c))
        }
        ```
Once you have a function, you can add more functions in the same file or start a new file with new functions. A key step here is to add an roxygen2 tag called `@export` above the function and run `devtools::document()`. This will both add the function to the NAMESPACE and export the function for users to use. Your function should look something like:

        ```r{}
        #' @export
         is_between <- function(a, b, c) {
        # function to check if a is between b and c
        if (b < a < c) {
            print(paste(a,"is between", b, "and", c))
          }
         print(paste(a,"is not between", b, "and", c))
        }
        ```
Note that if your function uses function(s) from some other package, you need to import the package. For instance, if you were using a dplyr function `between()` in the `is_between()` function, the code will be:

        ```r{}
        #' @export
         is_between <- function(a, b, c) {
        # function to check if a is between b and c
        if dplyr::between(a,b,c) {
            print(paste(a,"is between", b, "and", c))
          }
         print(paste(a,"is not between", b, "and", c))
        }
        ```
Using `dplyr::between` instead of `between` is important for R to recognize that you are using the external package `dplyr`. You also manually have to add the external pacakge, in this case `dplyr`, under `Imports:` in the DESCRIPTION file.

        Imports:
            dplyr
            
You can add multiple external packages under Imports, just make sure to put comma after each package name. Beyond Imports, there are also options to add to Depends and Suggests. I use Depends for only the external packages that users need to explicitly load with `library()` while loading my package. I usually just add the version of R needed for my package and some crucial packages like `ggplot2` in the Depends option. All the other external packages used and needed for my package goes under Imports. Finally, only the packages used for development, examples, vignettes, and tests go under Suggests. You can learn more about pacakge dependencies [here](https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Package-Dependencies). 

Once you have your function(s), either run `devtools::load_all()` or Build -> Install and restart to run and load your package. You should then be able to use your package, check your functions in the console. 


##### Documentation

Once you write your function(s), it's time to document it. Again, this is another place you really want to think the difference between running a script versus writing a package; you want to document your package so clearly and thoroughly that a completely new user can understand it. I always put myself on a user's shoes when I am documenting my code. Thanks to [roxygen2](https://roxygen2.r-lib.org/), most of this is automated for us. You want to use various roxygen2 tags to document your function. For example, I would document our `is_between()` function as below:

        ```r{}
        #' Check if a number is in between two other numbers
        
        #' This function checks if the first number is between the second and 
        the third number.
        #'
        #' @param a A scalar to check.
        #' @param b The left boundary value (must be a scalar).
        #' @param c The right boundary value (must be a scalar).
        #' @return A character.
        #' @export
        is_between <- function(a, b, c) {
        if dplyr::between(a,b,c) {
            print(paste(a,"is between", b, "and", c))
          }
         print(paste(a,"is not between", b, "and", c))
        }
        ```
To learn more about various [roxygen2](https://roxygen2.r-lib.org/) tags, please read [here](https://r-pkgs.org/man.html). 

Once you are satisfied with the documentation, simply run `devtools::document()` to save the documentation in the man folder. This is what will enable the users to see the documentation using `?is_between`. Do not edit these files by hand. Make sure to document well and run `devtools::document()` anytime you work on your package. 

##### Tests

This is something I learned this summer, anytime you write a function for your package, you want to write tests for it. This not only makes sure that a function is doing what it's supposed to do, it will make your life much easier when trying to debug any kind of issues in the function. Understanding the concept of formal automated testing in R called **unit tests** and using them generously is a key step to writing a robust R package. Start by creating tests folder in your package directory using `usethis::use_testthat()`. When possible for every step of your function, you want to write unit tests, which are tests in R that are organised hierarchically: expectations are grouped into tests which are organised in files. To learn more about unit tests, check [this](https://r-pkgs.org/tests.html) out. Once you have written your tests, you can either use `devtools::test()` or simply click on Run tests to run them. Make sure all your tests pass before you proceed.

##### Check

Once you have written your functions, documented them, and written tests, it's time to check your package. There are two main ways to check your package:

* Build Check: In your local server you can either run `devtools::check()` or click on Built -> Check to check your package. Make sure to run Build -> Install and restart and `devtools::document()` before you check. Your goal is to make sure that there are no errors, warnings, and notes at the end. 

* Github Actions: I think of Github Actions as little computers which will do what we want them to do. By setting up and using Github actions, we are basically running command check on our package on different kinds of computers with different operating system and different versions of R. This will eliminate the chances of having something in our package that is specific to our device. Additionally, it allows for [Continuous Integration (CI)](https://en.wikipedia.org/wiki/Continuous_integration), meaning we can run the checks on the package automatically every time there is any change to the source code. Github Actions is a powerful tool to automate checking process for your package, to learn more, read the README.md [here](https://github.com/r-lib/actions). You can set up Github actions using codes similar to the following in your console. 

        pr_init("GHA")
        use_tidy_github_actions()
        usethis::use_github_action(url = "https://raw.githubusercontent.com/tidymodels/.github/master/pkgdown.yaml")
        pr_push()

Anytime you change and add anything to your package, you want to push the changes to Github and make sure all the Github Actions checks pass. 

##### Miscellaneous

* **Data:** If you need data for your package development, you can store them in one of these three folders in your package: data, inst/extdata, and R/sysdata.rda. To learn more about storing data in your package, read [this](https://r-pkgs.org/data.html). The easiest way is to use `devtools::use_data()` on the data object you want to store and show to users. For example:

```{r}
a <- 2:4
devtools::use_data(a)
```
This will save the data in data/a.rda and can be accessed while using the package.

* **Vignettes:** In addition to the documentation and README.rd in the github repository, you can use vignettes to give users more information and guide about the package. This is a great place to write step-by-step guide to use the package and a good example using your package. I treat vignettes like blogs. You can create vignettes in your package simply by running `devtools::use_vignette("users_guide")` for <devtools 2.1.0 or `usethat::use_vignette("users_guide")` for >devtools 2.1.0. This will create a vignettes folder with vignette/users_guide.Rmd in your package folder. You can now edit the vignettes. 

* **Pull Requests (PRs):** Pull requests in Github are like edit comments and suggestions in a Google doc. By creating a pull request, you are asking to review, change, and comment on your work. Creating pull requests at every required step is a convenient way to both tell others about changes you've pushed to a branch in your repository and get feedback on your code. You can do this directly on Github or in your console using `pr_init("first_pr")`. Make sure you are on your main branch when you first create the PR and run `pr_push()` when you are ready to push and create the PR in Github. You can add collaborators and reviewers in your PRs. When someone commits or comments on your PR, you can either accept or decline their suggestions and merge the PR to the main branch. A pro tip: create a draft PR instead of a PR until you are absolutely ready to have your work reviewed. 

* **Github Issues:** Issues are like to-dos while working on your project. It can be about anything from proposed extensions, bugs., things in progress, and reminders to yourself. Creating, organizing, and prioritizing issues while working on your package will really help you organize your development workflow. Take a look at the Github repositories of few existing R packages to learn more about how to effectively use issues. 

* **[{styler}](https://github.com/r-lib/styler):** {styler} formats all your code as per the tidyverse style guide. Running {styler} on your package frequently will format your code so that you can just focus on the content of your code. You can install styler using 
        ```{r} 
        install.packages("styler")
        ```
You can style your entire package using `style_pkg()` or individual file using `style_file()`. You can even apply the styler package using RStudio Addin. 

![](https://media.giphy.com/media/6el9OyEbZoPocbqmwT/giphy.gif?cid=790b76113bd2c4de9cc8e6d37e9a286b70685ec10384b4b0&rid=giphy.gif&ct=g)

Congratulations, if you made it this far, you have built your own R function package. Now, anyone can install and use your package using the following code.

```{r}
devtools::install("yourusername/packagename")
```
I highly recommend reading [Hadley Wickham](http://hadley.nz/)'s book on [R Packages](https://r-pkgs.org/) and [Advanced R](https://adv-r.hadley.nz/) for anyone looking to write their own R package.  


Step-by-step guide to writing a function package in R

Write your own R package

/images/ea1935c191a16fd35072618e68bb91664680c7e0.png

plotly::ggplotly() is an R function that converts a `ggplot2::ggplot()` object
to a `plotly` object. It is an incredible tool to create interactive web-based
graphs with `ggplot2::ggplot` aesthetics. You can also easily manipulate a
`ggplotly` object with the `style` function. An easy example of plotly::ggplotly() is given below.

        ````{r}
        library(ggplot2)
        library(plotly)

        p <- ggplot(mpg, aes(displ, hwy, colour = class)) + 
          geom_point()
        ggplotly(p)
        ```

The interactive features of the plotly::ggplotly() function can be super useful while displaying a plot output in a shiny application.  If you have used plotly::ggplotly() inside a shiny application within a `renderPlotly()`  context, you might have noticed the sizing and label placements is not accurate by default. This is because while converting a `ggplot` object to a `ggplotly` object, `plotly::ggplotly()` uses the size of the current graphic device, and if no device is located or provided, the default values are 640 for width and 800 for height. These default values might not be appropriate for all your shiny application so the placement of the labels is not always correct. An easy fix to this problem is to specify the height and width of the plot output container in a shiny app. The easiest way to do this is to create
a new function, call it `ggplotly2`, that modifies the original `plotly::ggplotly()`
function to customize the width and height of the plot output based on the container.

        ```{r}
        library(plotly)
        
        # Let ggplotly() know about the size of it's output container
        # (only works when being called within a renderPlotly() context)
        ggplotly2 <- function(x, ...) {
          info <- shiny::getCurrentOutputInfo()
          height <- if (is.function(info$height)) info$height()
          width <- if (is.function(info$width)) info$width()
          plotly::ggplotly(x, width = width, height = height, ...)
        }
        ```

Note that the customizing only works when called within a `renderPlotly()` context.
Now, you can use the function `ggplotly2()` instead of `plotly::ggplot()` to convert
a ggplot object to a `ggplotly` plot output with proper sizing and label placement
inside a shiny application.

         ````{r}
        library(ggplot2)
        p <- ggplot(mpg, aes(displ, hwy, colour = class)) + 
          geom_point()
        ggplotly2(p)
        ```

You can use a similar method to modify a Plotly object based on other container information
like foreground color, background color, font style etc. For shiny users, this is
a good example of controlling codes to run at the different life cycle of shiny
application, which is a pretty handy tool.


Make your pretty plotly::ggplotly plot prettier

Size of a ggplotly object inside a shiny app

###### About Peer Career Advisor (PCA)

I worked as a [Peer Career Advisor ](https://www.reed.edu/beyond-reed/peer-career-advisors/index.html)for the last two years at my alma mater Reed College, Portland, OR. PCAs are the student employees who work at the school's career center to connect students to opportunities and resources. As PCAs, we receive in-depth training and we work closely with the staff at the career center to keep a working knowledge of job search strategies and various opportunities. We assist our peers with writing resumes, cover letters, and personal statements, preparing for interviews, networking, searching for internships/jobs/opportunities, and helping with various applications.

One of the main reasons why I worked as a PCA at my school was to make career resources as accessible and equitable as possible. From my own personal experience, finding the right opportunity and resources at the right time makes all the difference, so as a PCA that was my main goal: to learn and share various opportunities with my peers. I must admit, in this particularly difficult time of the global pandemic, working as a PCA was the most gratifying thing for me. Getting to work with my fellow peers (the majority of whom were freshmen) on jobs/fellowships/projects they are passionate about was a huge source of inspiration to me. I made friends with so many of my advisees and I got to be a part of their various career adventures. I have learned and grown so much through all the interactions I have had with my advisees and through the job overall. So this post is all about sharing all those useful resources/skills I learned through the position that has helped me navigate various professional endeavors.

*   **Resume:**  A resume is a one-page tailored document that summarizes your experiences, skills, and qualifications for the position you are applying for. My rule of thumb is, make sure the resume is clear, concise, and communicative, both in terms of content and formatting. There are certain “rules” that a standard one-page resume is supposed to follow; so I usually have a recyclable template ready to go. [Here are the templates](https://drive.google.com/drive/folders/1asCWkH4oCRQkZ6uhz4p8kuzTCY431wrc?usp=sharing), they only differ in appearances so it’s up to your personal preference which one you use. Feel free to make your own copy and use it. I recommend having a master copy (length does not matter) with all the experiences and selecting a few relevant experiences to tailor it towards the jobs/fellowships you are applying for. [This document](https://drive.google.com/file/d/1atXueyFAyGpP52PVleZyJwuZokngv3gs/view?usp=sharing) is helpful to get started.

*   **CV:** If you are in academia or are applying for graduate schools, CVs may be preferred/required. A CV is similar to a resume in that it contains your experiences, skills, and qualifications, but a CV differs in that it is not as tailored and contains the full history of your academic and work experiences. So, it is usually longer than a resume, usually 2-4pages. Similar to the resume, I use a template that follows all the “standard” rules for a CV and edit it as I go. [Here is the template](https://drive.google.com/file/d/14\__Zl-RmWPwxSlK4aW6rhYWeuHhe1bfx/view?usp=sharing) I use, feel free to copy and use it.

*   **Cover Letter:** A cover letter is commonly submitted along with a resume/CV during a job application to outline one's interest and qualifications for the position. If there are set prompts for the cover letter, stick to the prompts and make sure you answer each of the questions/prompts clearly. If there is no prompt, use the cover letter to answer these three questions: why you? why that position? why that company? Make sure the cover letter is not just an elaborated version of your resume. I think of a cover letter as a chance to make a personal case on why I am interested in and qualified for the position, so I often approach it as my chance to add the personal touch to the otherwise mostly technical application process. [Here is the template](https://docs.google.com/document/d/1qOrZbJtHvVribJ8JMzm9\_wUnthnmXpTh3Fjt-Z6yQw4/edit?usp=sharing) I use while writing cover letters and [this document](https://drive.google.com/file/d/1dvy-KbBdxKwxwDb3l-omKoslL2yDfXJK/view?usp=sharing) is helpful to get started.

*   [LinkedIn:](http://www.linkedin.com/) I think of [LinkedIn](https://www.youtube.com/watch?v=ZVlUwwgOfKw) as social media for professional purposes. I mostly use it for networking, it's easier to find people and message them on LinkedIn, and in my experience, the response rate is higher and faster. I would recommend putting some time in the beginning while setting up the profile; I used [this video](https://www.youtube.com/watch?v=aSwGU3WQL78) to get me started. Also, look at a bunch of different people's profiles (within your network or simply google it or check pages [like this](https://www.linkedin.com/showcase/best-linkedin-profiles-examples)) for reference. Remember you might not be able to send connection requests to just anyone, so try adding a person you know who might have connections you might be interested in, that way you can eventually send a request to them. Look out for your school's LinkedIn alumni directory ([like this)](https://www.linkedin.com/school/reed-college/people/), I use the LinkedIn directory more often than the one on the school's website. In terms of content, it can be intimidating to get started, so feel free to test and decide what kind of content you feel comfortable sharing on this platform; everyone has a different comfort level so do not feel pressured to post as much or as little as someone else. Also, like with any other social media, it can get overwhelming at times, so take a break when you need to.



*   **Other:**

    *   [**Canva:**](https://www.canva.com/) Using Canva to make presentations can really make your slides stand out. There are so many good free templates on Canva and once you get a hang of it, it’s pretty easy to make your own template as well. 

    *   **Meeting Notes:** My rule is when in any kind of professional meeting, take notes. It really helps me remember what we discussed in the last meetings and if we had planned any agenda for the ongoing meeting. It is also a great way to stay focused during meetings. On that note, if you are applying for multiple jobs/schools/fellowships, I always make a master doc [like this](https://docs.google.com/spreadsheets/d/1Q0wUT677aGgEmpoVfmf0\_kNAH7x-Ay3qb9-NbYwX0mI/edit?usp=sharing) to keep track of my progress in the application process. I use [google docs](https://www.google.com/docs/about/) to take notes and [google sheets](https://www.google.com/sheets/about/) to make a master tracking sheet.

    *   **Drive:** This might be a very me thing but every time I start a new project (for class or job or personal projects), I start a drive folder. I am a very visual learner so having all my relevant files in one place really affects my motivation and focus to work on projects. It is also great for backup; I can’t emphasize this enough, having some form of online backup of all the projects I am working on is super important, both for easy accessibility and retrieval. I use [google drive](https://www.google.com/drive/) and [dropbox](https://www.dropbox.com/). 

    *   **Career Advising Resources:** I realize that it’s my privilege to have access to a career center and career advisors anytime I am applying for something, so I do not want to assume that everyone reading this has that. But the good news is, most schools’ career advising websites are public. Throughout my undergraduate, along with my school's career center, I extensively used other schools’ career advising websites/resources. Most of the websites have detailed information about document templates, different fellowships, tips, and resources; I would highly recommend browsing through some top schools’ career websites (you can just google “xyz career advising center” and go from there.) I have also used [LinkedIn Job Search Engine](https://www.linkedin.com/jobs/) and [Handshake](https://joinhandshake.com/). Also, the websites like [Vault](https://www.vault.com/) and [Goinglobal](https://www.goinglobal.com/) (great for international opportunities) have some really useful resources. 

    *   **Calendar:** Again, this might be my organization freak brain speaking but I try to put everything--my schedule, reminders, tasks, invites, etc.-- on my google calendar. It really helps me to plan my days and stick to it. A very important note here, please make sure to block out some time for yourself in your calendar, just write busy or explicitly plan things for yourself. No matter how busy it gets, always make some intentional self-care time for yourself. I use [Google Calendar](https://www.google.com/calendar) as my everyday calendar. 

    *   **To-Do-Lists:** I call myself “a bullet points person”, I love being able to see everything I have to do in bullet points. From my job tasks to grocery shopping, I use lists pretty extensively to keep track of stuff I need to do; it is also really satisfying to me to cross things off my list. I use [Microsoft’s To Do](https://todo.microsoft.com/). 

    *   **Thank you notes:** Every time after a professional meeting or an interview, sending a brief thank you note (either over email or via postcard) goes a long way. 

    *   **Talk to others:** This is the step I never skip while applying for something: talking to someone who has done or is doing what I want to do. When applying for fellowships, I look at the past proposals and talk to the past recipients and when applying for jobs, I try to find a current employee to talk to; that way, I always learn things I would not have learned otherwise.

I think that’s all I can think for now. Feel free to contact me if you have any questions about any of these things or if you have anything I can add to this blog. Much appreciate your time.🌻🌝

Resources I learned about working as a Peer Career Advisor (PCA)

All Things Peer Career Advising (PCA)

##### 2021

###### [पिजडाकि चरी](https://youtu.be/opAlM8OBUDg)

My recent spoken poetry about domestic violence in Nepal.

पिँजडा जती सुकै ठुलो किन नहोस, तेस भित्रको चरी बन्धी नै हुन्छ, र कृपया हामी–छोरी,बुढी, बैनी, बुहारी–लाई त्यो पिजडा सिँगार्न हैन, फोर्न सिकाऔँ! महिला हिंसा अन्त्य गरौँ!

###### [shinymodels  internship at RStudio](https://blog.rstudio.com/2021/03/02/summer-internship-2021/)

The tidymodels framework is a collection of packages for modeling and machine learning using tidyverse principles. The goal of this internship is to create a package that, given a tidymodels object, will launch a Shiny application.
*Mentor: Max Kuhn*

###### [Evan Rose Fellowship Urban Planning Research Project](https://www.reed.edu/beyond-reed/fellowships-awards/sponsored/EvanRose.html)

Will conduct a research project exploring whether the urban development vision of smart cities could be a solution for inequality and sustainability issues. I will work with Prof. Jasmine Jiang in the Reed College Economics Department.

###### [Undergraduate Senior Thesis at Reed College, Portland, OR](https://drive.google.com/drive/u/2/folders/1H5c3GWElXCtgYBll3x5YN0oh_M1-cds\_)

Title:  Inequality in Ramsey Growth Model with Heterogeneous Rates of Return: Are rich getting higher returns on investment than poor?

Advisor:  [Prof.  Jasmine Jiang ](https://twitter.com/ZheJasmineJiang)

Built a modified Ramsey model with heterogenous returns on capital investment; conducted an empirical analysis of existence, causes, and implications of different returns on investment for rich and poor households; showed that rich get higher returns on investment than poor.

###### [Spease](https://github.com/olekwojcik/spease)

In collaboration with a classmate Olek Wojcik, wrote an R package to run the G, K, and F spatial functions on sf objects. This was the final project for the Spatial Data Analysis class taught by Jonathan Kadish in Spring 2021 at Reed College. [Here is the presentation](https://drive.google.com/file/d/19GBfl8heQHSxbhm6u3OPMmeUFTi8BtxO/view?usp=sharing) for the package.

##### 2020

###### [Police Brutality in the US (An independent study)](https://drive.google.com/drive/u/2/folders/1e6jEsFHn7lg4oSImkNpq9bfycY0nf0Zu)

Advisor: [Prof. Silvia Borzutzky ](https://www.heinz.cmu.edu/faculty-research/profiles/borzutzky-silvia)

Amidst the Black Lives Matter movement in the summer of 2020, conducted an independent study and wrote a paper on police brutality in the US.

###### [Visualizing Inequities in Seattle](https://github.com/adhikars11/PPIA_Data_Science_Project)

This project was conducted by Shisham Adhikari and Domnick Ta as a part of the Public Policy and International Affairs (PPIA)--Data Analytics Track 2021 program at Carnegie Mellon University. There is a large body of articles that have clearly demonstrated a fact that there is clear income inequality and de facto racial segregation in Seattle. However, there has never been a visual to provide an intuitive spatial understanding of this phenomenon and this project is an attempt to fill the gap. Here is the [final blog.](https://homes.cs.washington.edu/~domta/seattle-inequity.html)

###### [GapMap](https://github.com/Reed-Statistics/GapMap)

In the light of the COVID-19 Pandemic, a Shiny R app created to explore the relationship between the severity (number of confirmed cases and deaths) of COVID-19 and health insurance coverage in the US at a county level.

###### [Swing Stacks: Predicting political party affiliation via model stack](https://github.com/Reed-Stat-Learning-Fall-2020/group\_3)

In the light of the US 2020 election, a collaborative project using tidymodels—namely, stacks—to layer multiple models and model types to better predict party affiliation using several socio-political predictors from the General Social Survey (GSS) dataset from 2000-2016. It was  the final project for Math 243: Statistical Learning at Reed College in Fall 2020. Authors of this project are Shisham Adhikari, Maggie Slein, and Grayson White.

##### 2019

###### Panchankanya Media Center Project

Received the Reed College Student Opportunity Subsidy(SOS) Grant to setup a media center in *Panchakanya*,  a village in Nepal. Collected donations to buy projectors, laptops, and study materials for the center.

###### [Eviction Data](https://github.com/Reed-Statistics/math241S20PkgGrp8)

Taking in consideration the increasing homelessness in the west coast states, worked in a team of three to create an R data package on eviction rate along with other related variables like income, rent, poverty rate etc. across West Coast States (California, Washington, and Oregon). The project is based on [this eviction data](https://evictionlab.org).

##### 2018

###### [Davis Peace Project of Peace ](https://www.davisprojectsforpeace.org/projects/projects/2018/node/6153)

Received $10,000 from the Kathryn W. Davis Projects for Peace fund to support women's mental health in post-disaster settings in Nepal. As a part of the project, traveled to 9 districts of Nepal conducting workshops and talk-in-groups about breaking the taboos surrounding the mental health of women and children.


Projects


Thank you for contacting me! I will get back in touch with you soon.

**Have a great day!**