Add full schedule

_config.yml

@@ -18,4 +18,6 @@ kramdown:
 plugins:
   - jekyll-seo-tag
 
+include: ['abstracts']
+
 exclude: ['README.md', 'Gemfile', 'Gemfile.lock']

abstracts/cell-flower.md

@@ -0,0 +1,17 @@
+---
+layout: default
+---
+
+## Cell FLOWer
+
+**Speaker:** Josef Hoppe
+
+**Website:** [https://github.com/josefhoppe/cell-flower](https://github.com/josefhoppe/cell-flower)
+
+**Abstract:** Obtaining sparse, interpretable representations of observable data is crucial in many machine learning and signal processing tasks. For data representing flows along the edges of a graph, an intuitively interpretable way to obtain such representations is to lift the graph structure to a cell complex: As a generalization of simplicial complexes, the eigenvectors of the associated Hodge-Laplacian also induce a Hodge decomposition, which can be used to represent the observed data in terms of gradient, curl, and harmonic flows. From this basis, we can topologically filter (i.e., denoise) these flows. Moreover, the cells of a cell complex that results in a representation which is both accurate and sparse capture an inherent structure of the observed flows which may lead to further insights.
+
+CellFlower implements the efficient approximate algorithm for this flow representation problem presented in Hoppe and Schaub (2024). It is a lightweight and easy-to-use python package, designed to work as a standalone library. For convenience, it also includes utility methods for easy interoperability with NetworkX.
+
+**Reference:**
+
+ - Hoppe, J., & Schaub, M. (2024). [Representing Edge Flows on Graphs via Sparse Cell Complexes](https://proceedings.mlr.press/v231/hoppe24a.html). In Proceedings of the Second Learning on Graphs Conference (pp. 1:1–1:22).

abstracts/networkit.md

@@ -0,0 +1,11 @@
+---
+layout: default
+---
+
+## NetworKit
+
+**Speaker:** Fabian Brandt-Tumescheit
+
+**Website:** [https://networkit.github.io/](https://networkit.github.io/)
+
+**Abstract:** NetworKit is a continuously growing open-source toolkit for large-scale network analysis. The goal is to provide tools for the analysis of large networks in the size range from thousands to billions of edges. For networks of this size, exact algorithms often do not finish in reasonable time. To solve this, NetworKit implements efficient and often parallel approximation algorithms. For dynamic graphs, NetworKit goes one step further and combines approximation with batch updates, enabling significantly reduced running time for time-varying real-world use-cases. In the talk we will cover how dynamic algorithms are designed in NetworKit and show the capabilities of the rich Python interface including visualization. As an example, we will deal with a fully-dynamic approximation algorithm for the popular Betweenness centrality.

abstracts/raphtory.md

@@ -0,0 +1,15 @@
+---
+layout: default
+---
+
+## Raphtory: fast temporal network analysis in Python, powered by Rust
+
+**Speaker:** Naomi Arnold
+
+**Website:** [https://www.raphtory.com/](https://www.raphtory.com/)
+
+**Abstract:** Temporal networks provide an essential framework for representing evolving or event-based systems ranging from financial transactions, social interactions to contact networks and the last decade has brought a variety of useful metrics and algorithms for understanding them. While there are now many actively-developed and feature-complete tools for working with static networks such as NetworkX, igraph and graph-tool, and for higher-order networks like PathPy, XGI and HypergraphX, no such equivalent has existed for temporal networks. In this presentation we introduce Raphtory, our multi-purpose library for analysis of large-scale temporal networks. Built by network scientists, Raphtory has been designed to represent as varied as possible notion of temporal network, from link-streams to edges with duration to sequences of network snapshots, and is equipped with an expressive API for querying the network over different times and timescales. As well as temporal attributes, nodes and edges can have properties/weights and edges can be part of a layer, allowing multi-layer, weighted and attributed networks to be represented easily. With large-scale networks in mind, the core of Raphtory is written in Rust which allows for fast and memory-efficient computation, whilst being wrapped in a fully-documented Python library so that no Rust knowledge is required of the user. Raphtory is equipped with a range of in-built algorithms, from static graph metrics that would be expected in a graph library to temporally focused ones such as δ-temporal motifs, topological-temporal reachability and temporal spreading simulations.
+
+**Reference:**
+
+ - Steer, B, et al. [Raphtory: The temporal graph engine for Rust and Python](https://arxiv.org/abs/2306.16309). _arXiv preprint_.

abstracts/rustworkx.md

@@ -0,0 +1,11 @@
+---
+layout: default
+---
+
+## Rustworkx
+
+**Speaker:** Matthew Treinish
+
+**Website:** [https://www.rustworkx.org/](https://www.rustworkx.org/)
+
+**Abstract:** Rustworkx is a general-purpose graph library focused on performance. It is written in the Rust programming language and provides both a Rust API and a flexible Python interface as well. Rustworkx focuses on building dynamic networks where you're interacting with graph data structures, modifying them, and analyzing them. This talk will provide an introduction to Rustworkx, the library's capabilities, and show some examples of current usage of the library.

abstracts/structify-net.md

@@ -0,0 +1,26 @@
+---
+layout: default
+---
+
+## Structify-Net
+
+**Speaker:** Rémy Cazabet
+
+**Website:** [https://structify-net.readthedocs.io/](https://structify-net.readthedocs.io/)
+
+**Abstract:** Structify-Net is a Python library to generate random graphs with custom structures, fixed number of nodes and edges. While most network libraries include network generators with block/community structure (e.g., Stochastic Block Models, SBM) and spatial/geometric structure (e.g., Random Geometric Graphs, RGG), generating graphs with other types of structures is typically not straightforward.
+
+With Structify-Net, one can define a structure by defining a **ranking/scoring function**, i.e., a function that, given two nodes characterized by their IDs and/or properties (coordinates in a space, attributes, category, etc.), return a score allowing to rank pair of nodes from most likely to be connected to less likely. By providing only:
+
+* This ranking function
+* A set of nodes
+* An expected number of edges
+* An amount of randomness ε ∈ [0,1]
+
+Structify-net returns a network generator, allowing the exploration of classic (blocks, geometric, nested, hierarchic, ...) and unconventional network structures, in a common framework.
+
+Typical applications of this library include (1) the study of network properties (clustering coefficient, average shortest path, ...), (2) the impact of network structure on diffusion processes, and (3) benchmarks for tasks such as community detection or link prediction.
+
+**Reference:**
+
+ - Cazabet, R., Citraro, S., & Rossetti, G. (2023). [Structify-Net: Random Graph generation with controlled size and customized structure](https://doi.org/10.24072/pcjournal.335)s. Peer Community Journal, 3. 

abstracts/xgi.md

@@ -0,0 +1,15 @@
+---
+layout: default
+---
+
+## CompleX Group Interactions (XGI)
+
+**Speaker:** Nicholas Landry
+
+**Website:** [https://xgi.readthedocs.io](https://xgi.readthedocs.io)
+
+**Abstract:** CompleX Group Interactions (XGI) is a library for higher-order networks, which model interactions of arbitrary size between entities in a complex system. This library provides methods for building hypergraphs (undirected and directed) and simplicial complexes; algorithms to analyze their structure, visualize them, and simulate dynamical processes on them; and XGI-DATA, a collection of higher-order datasets. XGI is implemented in pure Python and integrates with the rest of the Python scientific stack. XGI is designed and developed by network scientists with the needs of network scientists in mind. We demonstrate this library's effectiveness by describing an example XGI workflow: first, choosing a higher-order dataset; second, extracting basic global statistics; third, calculating structural measures such as connectedness, assortativity, and centrality; third, converting higher-order datasets to different mathematical representations; fourth, leveraging the statistics module to filter the dataset; and lastly, visualizing the higher-order networks in various ways.
+
+**Reference:**
+
+ - Landry et al., (2023). [XGI: A Python package for higher-order interaction networks](https://doi.org/10.21105/joss.05162). Journal of Open Source Software, 8(85), 5162.

schedule.md

@@ -6,10 +6,25 @@ layout: default
 
 The satellite will take place on Tuesday, June 18 in the morning, followed by a hands-on tutorial in the afternoon.
 
-| Time          | Event                                                                      |
-| ------------- | -------------------------------------------------------------------------- |
-|  9:00 –  9:30 | Introducing the [Network Analysis Software Collective](https://nascol.net) |
-|  9:30 – 10:30 | Community discussion on the state of network science software              |
-| 10:30 – 12:30 | Contributed presentations (details to follow)                              |
-| 12:30 – 14:30 | Lunch break                                                                |
-| 14:30 – 18:00 | Tutorial on cross-package network analysis in Python                       |
+| Time  | Speaker                  | Title                                                                      |
+|------:| -------------------------|----------------------------------------------------------------------------|
+|  9:00 |                          | Welcome and introduction                                                   |
+|  9:05 | Vincent Traag            | Introducing the [Network Analysis Software Collective](https://nascol.net) |
+|  9:30 | Fabian Brandt-Tumescheit | [NetworKit][1]                                                             |
+|  9:50 | Naomi Arnold             | [Raphtory][2]                                                              |
+| 10:10 | Nicholas Landry          | [CompleX Group Interactions (XGI)][3]                                      |
+| 10:30 |                          | **COFFEE BREAK**                                                           |
+| 11:00 | Matthew Treinish         | [rustworkx][4]                                                             |
+| 11:20 | Rémy Cazabet             | [Structify-Net][5]                                                         |
+| 11:40 | Josef Hoppe              | [Cell FLOWer][6]                                                           |
+| 12:00 |                          | Community discussion on the state of network science software              |
+| 12:30 |                          | **LUNCH BREAK**                                                            |
+| 14:30 |                          | [Tutorials on cross-package network analysis in Python][7]                 |
+
+[1]: abstracts/networkit
+[2]: abstracts/raphtory
+[3]: abstracts/xgi
+[4]: abstracts/rustworkx
+[5]: abstracts/structify-net
+[6]: abstracts/cell-flower
+[7]: school