{'fraction_non_alphanumeric': 0.03695007414730598, 'fraction_numerical': 0.008928571428571428, 'mean_word_length': 4.720926122304701, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
CSSR: A Context-Aware Sequential Software Service Recommendation Model

We propose a novel software service recommendation model to help users find their suitable repositories in GitHub. Our model first designs a novel context-induced repository graph embedding method to leverage rich contextual information of repositories to alleviate the difficulties caused by the data sparsity issue. It then leverages sequence information of user-repository interactions for the first time in the software service recommendation field. Specifically, a deep-learning based sequential recommendation technique is adopted to capture the dynamics of user preferences. Comprehensive experiments have been conducted on a large dataset collected from GitHub against a list of existing methods. The results illustrate the superiority of our method in various aspects.


Introduction
With the development of emerging computing areas such as cloud computing, big data, and Internet of Things, the Web-based services available on the Internet have increased rapidly in both quantity and type [3]. Following [1], software service is specifically defined as services which contain code under open-source licenses for others to use and modify freely, such as open-source projects or repositories on social coding sites (e.g., GitHub 1 , Bitbucket 2 , SourceForge 3 ). Users can build their Web services, applications, or even scientific experiment systems quickly by exploiting functional code modules in massive software services [13].
As a representative software service hosting platform, GitHub is widely known to developers from all over the world, who find it easier and quicker to build up their complex applications from particular repositories. As of January 2020, GitHub reports having over 40 million users and more than 100 million repositories [4], making it the largest host of software services in the world. The large number of repositories has undoubtedly increased the difficulty of selecting the most suitable ones to fulfill users' application development. Therefore, software service recommendation has become of practical importance [21]. McMillan et al. [9] designed a tool named CLAN to help users detect similar applications. It used latent semantic indexing to measure the similarity of repositories relative to API usage. However, it is limited to Java applications and small-scale data. LRMF [6] is a pairwise regularization framework for GitHub open source repository recommendation based on matrix factorization, focusing mainly on exploiting user language preference. PNCF [1] is the state-of-the-art repository recommender model, which combined deep learning with collaborative filtering to enhance recommendation effectiveness, and also focused on language preference.
The above methods proposed effective strategies to make software service recommendation. However, they suffer from the following two common issues. First, the well-known data sparsity problem is not addressed. Although the number of users and repositories on GitHub can be very large, the interactions between users and repositories are highly sparse, i.e., most users typically interact with a few repositories. Second, user preferences may exhibit dynamic characteristics. For instance, users' preferences may drift over time due to the continuous evolution of software technology and the influence of other users. To address the two aforementioned issues, a novel recommendation model named CSSR (Context-aware Sequential Software Service Recommendation) is proposed in this paper with two unique traits. Firstly, there is a consensus that contextual data can be utilized as complementary information to alleviate the data sparsity issue in general recommender systems [18]. Each original repository on GitHub has rich contexts as depicted in Fig. 1. We leverage more comprehensive contextual information of repositories (i.e., topics, general description, README ) compared with the state-of-the-art recommendation methods [1,6]. It can model the similarity between repositories more precisely to make better recommendation when the interaction data is sparse. Secondly, users on GitHub interact with repositories in a chronological order as depicted in Fig. 1. The temporal information of user interaction behaviors can help to model users' dynamic interests. For example, it is reasonable to assume that a user is most likely to access the repositories which are relevant to the repositories the user has interacted with recently. Therefore, we adopt sequential user-repository interactions to capture the dynamics of user preferences. More specifically, CSSR first explores contextual information to construct a repository graph upon which the latent vector of each repository can be derived through the graph embedding. Then, the repository sequences of users are fed into a GRU model, where the latent vector of each repository is applied, to identify the appropriate repositories and recommend them to users. We have conducted comprehensive experiments to compare CSSR with the state-of-the-art methods on a large real-world dataset crawled from GitHub 4 . The experimental results show that CSSR achieves at least 16.16%, 22.05% and 11.35% improvements over the best baseline in terms of Hit Rate, Mean Reciprocal Rank and Normalized Discounted Cumulative Gain respectively, and the performance boost is more significant in the situation of high level of data sparsity. Our contributions are summarized as follows: -This study proposes a context-aware sequential software service recommendation model (CSSR) to improve software service recommendation by mitigating the difficulties caused by data sparsity and the dynamic characteristics of user preferences. -We design a repository graph construction method. It takes full advantages of the context characteristics of repositories on GitHub, upon which the recommendation performance can be improved. -This study, to the best of our knowledge, is the first work that explores the sequential interactions in software service recommendation to model the dynamics of user preferences.
The rest of paper is organized as follows: Sect.2 introduces the related work; Sect.3 formulates the software service recommendation problem; Sect.4 presents the CSSR model; Sect.5 is the experiments and result analysis, and Sect.6 is the conclusion.

Related Work
In this section, we will briefly review several lines of works closely related to ours, including sequential recommendation, service recommendation and software service recommendation.
Sequential Recommendation. The technology of recommender systems continues to develop. This results from their significant role in helping users alleviate the problem of information explosion and select interesting contents in many Web application domains. Meanwhile, many recommendation techniques have been designed, including collaborative filtering [12], matrix factorization [10], factorization machine [7], and deep-learning-based methods [18]. Sequential recommendation is a critical research topic of recommender systems, and has been extensively studied over years. It views the interactions as a sequence in a time order and aims to predict the successive items that a user is likely to interact with in the near future. Traditional methods [11] utilized Markov Chains to capture item-item transitions for sequential recommendation. Recently, deepsequential-neural-model-based methods [5,14] have shown much superior performance. They utilized different sequential neural networks (e.g., RNNs, Transformers) to address concrete issues from different aspects and domains. Aiming at validating the effectiveness of sequential recommendation in software service domain, we adopt the classic sequential neural model GRU [2] fusing with graph embedding techniques to solve next repository recommendation issue.
Service Recommendation. Lots of research works have been done on service recommendation in recent years. They can be mainly classified into two categories, i.e., QoS-based service recommendation [8] and functionality-based service recommendation [20,19,17]. However, QoS-based service recommendation approaches cannot help developers find an unknown but interesting service, limited by their objective. Functionality-based service recommendation approaches focus on finding the services that meet the functional requirements the best. Among them, the semantic-based approaches [20] aim at finding services with the highest matching degree via semantic similarity computation. The socialnetwork-based approaches [19] tend to apply user interest, social relationship and link prediction. The information-network-based approaches [17] mainly employ different kinds of information and multiple semantic meanings of meta paths to recommend services. In this paper, we focus on recommender systems for a special kind of Web-based services, i.e., software services.
Software Service Recommendation. Software services are the services with a focus on providing various code resources to facilitate software development. GitHub is the largest software service providers. It opens access to the information of repository, users, and the interactions between them. This attracts much interest of researchers, and currently most studies in software service recommendation are for GitHub repositories. Jiang et al. [6] proposed a repository recommendation model based on matrix factorization. Chen et al. [1] combined deep learning with collaborative filtering to do repository recommendation. The above two methods both concentrated on exploiting user language preference. Sun et al. [15] proposed an approach to recommend repositories considering both user behaviors and repository features. Shao et al. [13] designed a novel crossplatform recommender system, paper2repo. It recommended relevant reposito-ries on GitHub that match a given paper, by integrating text encoding and constrained graph convolutional networks.
In summary, the study in software service recommendation is still in its early stage. None of the existing studies pay attention to making performance analysis in different sparsity levels and addressing the really severe data sparsity issue, together with the problem of dynamic characteristics of user preferences. This paper aims to fill the research gap.

Problem Formulation
Each user has interacted with a sequence of repositories ordered by time on GitHub. The repositories may be created by a user directly or forked from other users, as illustrated in Fig. 1. Each repository has contextual information.
Let U = {u 1 , u 2 , ..., u |U | } and R = {r 1 , r 2 , ..., r |R| } be sets of users and repositories, with |U| and |R| being the sizes, respectively. Each user u can be associated with a sequence of repositories R u = {r u 1 , r u 2 , ..., r u |R u | } by sorting interaction records in a chronological order, where r u t represents the repository that user u interacted with at time step t. R u t1:t2 (t 1 < t 2 ) refers to the subsequence from interaction r u t1 to r u t2 . We learn how to recommend the next repository for each user based on the recent repository subsequence of length L the user interacted with, where L is a hyperparameter. For each user u at time step t, we will have a training data record where the features are R u t−L:t−1 and the label is r u t . For all users from t = 1 to t cur − 1 (t cur denotes the current time step and t cur − 1 is greater than L), we will obtain a training data set. Based on it, the research problem investigated in this study is to (1) represent user preferences and repositories, and (2) develop a prediction model to identify and recommend the preferable repositories to users. The objective is to optimize the performance by addressing the data sparsity issue and the dynamics of user preferences along with time.

Methodology
As illustrated in Fig. 2, the proposed model named CSSR (Context-aware Sequential Software Service Recommendation) consists of three steps: (1) constructing a repository graph by leveraging contextual information of repositories; (2) feeding the constructed graph into a graph autoencoder to derive embedding of each repository, which is fused with other features to form final repository latent vectors; (3) predicting the probability that each repository will be preferred by each user using a GRU model. These steps are detailed respectively in the following subsections.

Context-Induced Repository Graph Construction
First, a repository graph is constructed where the text-based contextual information is exploited. On GitHub, developers usually tag their repositories with  topics using words or phrases. The topics are suggested by a topic extraction framework, called repo-topix, which was developed by GitHub considering many engineering problems. We utilize the topics tagged by users with the suggestion of repo-topix directly rather than extracting the similar information using topic modeling like in existing studies. However, some repositories may not be tagged with such information explicitly or tagged incompletely. We then, for each repository, exploit its general description and README to derive and complete its topics by techniques such as keyword matching against the explicitly-tagged topics. In addition, the programming language of a repository can also be used as a special kind of topic-like information. This is because users are more likely to find source codes with languages they have used before.
Given any two repositories r p and r q , RT p = {rt p·1 , rt p·2 , ..., rt p·|T | } and RT q = {rt q·1 , rt q·2 , ..., rt q·|T | } are their corresponding repository topic vectors. The similarity between r p and r q is measured using cosine distance between RT p and RT q as follows: The similarity ranges from 0 (meaning that two repositories don't have any same topic) to 1 (meaning two repositories have the exactly same set of topics). We further define a hyperparameter in our model, i.e., the edge keeping threshold ε ∈ (0, 1), which is used to help generate an effectual and simple graph. With the threshold, the similarity between r p and r q is refined as follows: Context-induced repository graph

Repository embeddings
Encoder Decoder First-order proximity cost L 1st for local structure preserving Second-order proximity cost L 2nd for global structure preserving Context-induced repository graph

Repository embeddings
Encoder Decoder First-order proximity cost L 1st for local structure preserving Second-order proximity cost L 2nd for global structure preserving After calculating the similarity of any two repositories, we can get a similarity matrix S = {s 1 , s 2 , ..., s |R| } ∈ R |R|×|R| , where s r = {s r,1 , s r,2 , ..., s r,|R| }. We represent each repository r as a vertex v r . So, there are {v 1 , v 2 , · · · , v |R| } vertices; and there is a link between two vertices v p and v q only if similarity s p,q is greater than 0. By this way, we obtain a homogeneous graph where the contextual similarity between repositories has been captured. The graph is called contextinduced repository graph.

Context-Induced Repository Graph Embedding
For nodes in a graph, graph embedding automates the process of extracting lowdimensional node feature vectors. It has been proved very useful in many downstream tasks, such as classification, link prediction and recommendation. Various graph embedding models have been proposed. For embedding the contextinduced repository graph G, we adopt Structural Deep Network Embedding model (SDNE) [16], a representative embedding model for homogeneous graphs. As illustrated in Fig. 3, a multi-layer autoencoder is extended to capture the non-linear structure of G. The first-order proximity characterizes the local graph structure (i.e., the direct links between repositories in G). The second-order proximity characterizes the global graph structure (i.e., the co-neighbor relations between repositories in G). They are jointly exploited in the embedding process.
Given the similarity matrix S = {s 1 , s 2 , ..., s |R| } of G, we feed s r = {s r,q } |R| q=1 , (1 ≤ r ≤ |R|) into an autoencoder. The input s r is the initial representation of vertex v r (i.e., repository r). The hidden representations for each layer in the encoder are shown as follows. where is the k-th layer hidden representations; W (k) and b (k) are the k-th layer weight matrix and biases respectively. K denotes the number of encoder layers.
Given the input data s r , we can obtain the final output of the encoder y (K) r ; and then obtain the reconstructed dataŝ r by reversing the calculation process of encoder (i.e., decoder).
The first-order proximity describes the pairwise proximity between vertices. Intuitively, it implies that two vertices in real-world graphs are always similar if they are linked by an observed edge. Recall the construction of the contextinduced repository graph G in Sect. 4.1, two repositories are certainly similar if they are linked by an observed edge in G. The first-order proximity cost function for local structure preserving is applied on the output layer of the encoder and defined as follows.
where s r,q is the similarity between any pair of vertices v r and v q in G, which is computed by Eq. (2).
The second-order proximity exploits the similarity of the vertices' neighborhood structures to capture the global graph structure. Intuitively, it assumes that if two vertices share many common neighbors, they tend to be similar. The second-order proximity cost function for global structure preserving is applied on the output layer of the decoder. It is shown as follows.
where means Hadamard product; s r andŝ r are respectively the corresponding input of encoder and the output of decoder for vertex v r (i.e., repository r); b r = {b r,q } |R| q=1 . If s r,q = 0, b r,q = 1; else b r,q = β > 1. That is, we impose more penalty to the reconstruction error of the non-zero elements than that of zero elements. For s r = {s r,q } |R| q=1 is the direct neighborhood data of repository r, the cost function L 2nd ensures the repositories with similar neighborhood to have similar low-dimensional feature vectors.
We combine Eq. (4) and Eq. (5) and jointly minimize the following objective function to preserve the first-order and second-order proximity simultaneously: We use the stochastic gradient descent algorithm to train the model. Through the trained model, each repository r ∈ R can obtain its initial embedding y (K) r ∈ R dr , where d r is the size of graph embeddings.

Sequential Repository Recommendation
The sequential repository recommendation component in the framework of CSSR is illustrated in Fig. 4. Recall, in a training data record, the features are R   and the label is r u t . More specifically, R u t−L:t−1 includes L repositories, i.e., r u t−L , · · · , r u t−1 . Correspondingly, the sequential recommendation component consists of L GRU (Gated Recurrent Unit) [2] blocks as shown in Fig. 4. The input of GRU block t − i (1 ≤ i ≤ L) is a nonlinear transformed vectorŕ u t−i of the combined feature vector of repository r u t−i . The repository combined feature vector is derived from graph embeddings as discussed in Sect. 4.2. It is coupled with a list of other repository features relevant to repository recommendation. The output of the last GRU block is the inferred repositoryŷ u (t) which will be compared against the ground truth (i.e., r u t , the label of the training record), and the GRU parameters will be learned. Next, we introduce the sequential repository recommendation modeling in more details.
Fusing Multimodal Features for Repositories. For each repository r i ∈ R(1 ≤ i ≤ |R|), we concatenate the features derived from context-induced graph embedding with other important features (i.e., the number of watches, stars and forks) to obtain its final representation. Note that these features have different numerical ranges. We adopt min-max scaling to normalize them into a real number between 0 and 1, and concatenate them with the graph embedding vectors. By this way, each repository r u i (t − L ≤ i ≤ t − 1) interacted with user u in Fig. 4 can get its final representation (denoted as r u i ∈ R dr+3 ) for a GRU model, where d r is the dimensionality of initial repository embeddings.
Generating User Representation. Next, we present how to derive the latent vector of user u at time step t via the GRU model based on repositories u interacted with before t.
Recall R u t−L:t−1 = {r u t−L , r u t−L+1 , ..., r u t−1 } is the sequence of repositories of size L interacted with u just before time step t. The user representation can be computed iteratively as follows.
where W in ∈ R du×(dr+3) , W z , W r , W u ∈ R du×2du are learnable parameters, and d u is the dimensionality of user embeddings. σ(·) is a logistic sigmoid function to do non-linear projection. is the Hadamard product between two vectors. z (i) and r (i) denote update gate and reset gate respectively. They control how information flows through the sequence. u (i) represents the hidden state vector, i.e., the representation of the user u at time step i. It is dynamic and can remember past states. r u i is the combined feature vector of the repository interacted with u at time step i.ŕ u i is its nonlinear transformed vector, here, as the input data of the i-th GRU block. Note that the dimensionalities of u (i) andŕ u i are the same (i.e., d u ) for the convenience of prediction, and u (t−L) = 0 when initializing. For simplicity, we use u (i+1) = GRU(u (i) , r u i ) to denote the above operations.
Recommending and Model Training. We then illustrate how to recommend repositories for u at t. Given a user u with a sequence of visited repositories R u t−L:t−1 , the embedding u (t) of user u at time step t can be computed by Eq. (7). Then, the rating score of each candidate repository r i ∈ R (1 ≤ i ≤ |R|) for user u is computed as follows.ŷ denotes the recommendation probability of repository r i to user u at time step t. Finally, we train the GRU model by minimizing the following objective function.
where T u denotes the training dataset of user u, and T t u ⊂ R denotes the training set of user u at time step t. We adopt the negative sampling strategy to train the model. T t u contains the repository r t u that user u interacted with at time step t and the randomly-sampled 10 negative repositories corresponding to r t u . y u (t) i denotes the ground truth. If repository r i = r t u , y u (t) i = 1. Otherwise, y u (t) i = 0. L reg is an L2-norm regularizer to prevent overfitting, and θ is the set of all learnable parameters.

Experiments and Evaluation
In this section, we conduct experiments to validate the effectiveness of the proposed model in capturing dynamics of user preferences and addressing data sparsity issue. We also analyze how the key hyperparameters affect the performance.

Dataset Description
We evaluate the proposed method on a large dataset crawled from GitHub. We use GitHub REST API to create calls to obtain the data in JSON format and store them in MongoDB. A user is considered to prefer a repository if the user forked it. This means the user produced a personal copy of someone else's repository so that she can contribute to it or use it as the starting point for her own. All the repositories that a user created or forked are listed in her Web page in a chronological order. We randomly select users who forked more than 5 repositories. For each selected user, we crawl the information of all her forked repositories (e.g. topics, programming languages, README ). Such information is used to construct context-induced repository graph. We eliminate repositories forked by fewer than 5 users. There are 2,616 users, 3,126 repositories, and 21,924 interactions in the dataset after preprocessing. The data sparsity is 0.268%.
To capture dynamics of user preferences, we also try to consider temporal information of user-repository interactions (e.g., the absolute time span, the relative time interval, the relative temporal position interval) in our model. However, the experimental results don't show performance improvement. Thus, CSSR just utilizes the sequential interactions to make repository recommendation as described above.

Baseline Methods
Next, we compare CSSR against the following baseline methods.
-Pop simply recommends top ranked repositories based on popularity in training data. -Item-KNN [12] recommends a user the repositories similar to the previously forked repositories by the user based on cosine similarity. -BPR [10] is a classic method for non-sequential recommendation, which optimizes a Matrix Factorization model using a pairwise ranking loss. -FFM [7] is the representative recommendation model based on factorization machine. It groups features into fields, and learns the interactions between users and repositories to complete the user-repository implicit rating matrix. -GRU4Rec [5] is a representative sequential recommendation model, which also utilizes GRU to model user action sequences. We feed randomly-generated repository embeddings into GRU blocks, and obtain the best performance by using Xavier initializer against other random number generators.
-PNCF [1] is the state-of-the-art GitHub repository recommendation method by building a preference-based neural collaborative filtering recommender model. We feed the model not only with the language features in the original paper but also all our utilized topic features to make it fair.

Experimental Settings
For constructing the context-induced repository graph, we conduct stemming and lemmatization on all topics tagged by users with the help of repo-topix, and extract 4,015 topics. Then, for each repository, we conduct tokenization, stop words removing, stemming, lemmatization, typo corrections, and string matching on its textual contexts to complete its topics as introduced in Sect. 4.1. RE, NLTK and Spacy packages of Python are used for these tasks. Next, we compute the cosine similarity between each pair of repositories by using Numpy package and save the constructed graph into a file by using Pandas package. The edge keeping threshold ε is set to 0.3, which can generate a reasonable number of edges. The final constructed graph contains 3,126 repositories with 168,039 edges between them.
For each user, we hold the first 80% of interactions as the training set. We then use the next 10% of interactions as the validation set for hyperparameter tuning. The latest 10% constitute the test set for reporting model performance.
We conduct experiments with each model for five times independently, and report the average results.
The hyperparameters are learned from the validation dataset and set as follows. The size of initial repository embedding is 140. The size of user embedding is 64. L = 4 means that the recent 4 interacted repositories are considered to infer recommendations. The learning rate is 0.009. The maximum number of epoch is 100 during the model training. All the experimental results of our model are achieved by using the above hyperparameter configuration settings if no specific situations are provided. The optimal hyperparameters of each baseline method are set based on the experiment reports of the relevant research papers. We implement our CSSR model in Tensorflow.
We adopt three commonly-used metrics to evaluate the recommendation performance, i.e., Hit Rate (HR@N ), Mean Reciprocal Rank (MRR@N ) and Normalized Discounted Cumulative Gain (NDCG@N ) where N indicates top-N ranked repositories. In general, HR@N doesn't care about rank position in the recommendation list, MRR@N considers only the position of the first matched recommendation, and NDCG@N is a full position-aware metric which assigns greater weights on higher positions. They reflect different aspects of recommendation quality. The higher values indicate the better repository recommendation quality for all the three metrics.

Performance Comparison
The experimental results of of CSSR and all the baselines are reported in Table 1. We have the following observations. (1) In most cases, the state-of-the-art base- Table 1. The performance comparison (The method with the best performance is starred and the method with the second-best performance is boldfaced; columns "KNN" and "GRU" denote the baseline "Item-KNN" and "GRU4Rec" respectively; column "Improv." denotes the improvement ratio of CSSR relative to the best baseline). line PNCF achieves the best performance than the other baseline methods. (2) The proposed CSSR consistently achieves better performance on all the metrics at different N values compared with all the baselines by at least 10%. Specifically, it improves the performance slightly more on the metric MRR than on HR and NDCG. It achieves slightly more performance improvement when N = 10 than other N values. (3) All the baselines except GRU4Rec are sequential-information free models. However, GRU4Rec doesn't outperform the other baselines by just using randomly-initialized repository embeddings. Compared with GRU4Rec, the significant improvement of CSSR validates the importance of the contextinduced repository graph embedding component in our model.

Impact of Data Sparsity
We compare CSSR and all the baselines at different levels of data sparsity. The aim is to evaluate the solution applied in CSSR for mitigating the issue of sparse data. Since each user has at least 3 repositories and a repository has at least one user, we delete at most 14,081 interactions in our dataset to simulate different settings of sparsity. Table 2 shows the performance of all the methods at three levels of sparsity, i.e., deleting all/half of/none of the 14081 interactions respectively. We set N =10, and adopt all repositories in the training set that a user has interacted with to train the model in the first two sparsity levels, i.e., the repository sequence length L is not fixed. From Table 2, we have the following observations. (1) The performance of all the methods gets worse and worse when the data sparsity changes from 0.268% to 0.182% and then to 0.096%. (2) Compared with all the baselines except Pop, the impact of data sparsity on CSSR is much weaker. CSSR can have much more stable performance than the other methods except Pop, and achieve more significant improvements against the best baseline in the sparser data set. (3) Although the impact of data sparsity on Pop is weaker than CSSR, the performance of Pop is very poor among baselines. In short, our model achieves the best performance and demonstrates robustness in the situation of data sparsity.

Sensitivity of Hyperparameters
The size of initial repository embeddings, the size of user embeddings, and the sequence length L are the three important hyperparameters in our model. In this study, we further investigate the impact of the three hyperparameters on the recommendation performance. We set N =10. Fig. 5 (a) illustrates the effect of the initial repository embedding size (i.e., the size of graph embeddings). We can see that our CSSR would achieve the best performance when the graph embedding size is 140. Fig. 5 (b) illustrates the effect of the user embedding size (i.e., the size of hidden state in the GRU model). We can see that CSSR would achieve the best performance when the user embedding size is 32 or 64. Fig. 5 (c) illustrates the effect of the sequence length L. We can see that CSSR would achieve the best performance when it equals 4.

Conclusion
This paper presented a context-aware sequential software service recommendation model-CSSR. It can recommend repositories on GitHub matching users' interests. CSSR is a joint model that incorporates a graph embedding technique into a GRU formulation to generate latent vectors of users and repositories. Specifically, graph embedding technique is leveraged to exploit rich repository contextual information to alleviate the data sparsity problem. The context-aware latent vectors of repositories are then fed into a GRU model, which captures the dynamics of user preference and eventually recommend repositories to users. The results of extensive experiments show that our method can significantly outperform the existing state-of-the-art repository recommender models in various aspects.