title: Research Papers

This page lists academic and industry research papers about Go or using Go as the implementation language.

2021

  • Gobra: Modular Specification and Verification of Go Programs (F. A. Wolf, L. Arquint, M. Clochard, W. Oortwijn, J. C. Pereira, P. Müller)

2020

  • Uncovering the Hidden Dangers: Finding Unsafe Go Code in the Wild (J. Lauinger, L. Baumgärtner, A. Wickert, M. Mezini)
  • Lightweight Preemptible Functions (S. Boucher, A. Kalia, D. Andersen, M. Kaminsky)
  • From Folklore to Fact: Comparing Implementations of Stacks and Continuations (K. Farvadin, J. Reppy)
  • Featherweight Go (R. Griesemer, R. Hu, W. Kokke, J. Lange, I. Taylor, B. Toninho, P. Wadler, N. Yoshida)
  • GoPi: Compiling linear and static channels in Go (M. Giunti)
  • Fencing off Go: Liveness and Safety for Channel-Based Programming
  • Breaking Type-Safety in Go: An Empirical Study on the Usage of the unsafe Package (D. Costa, S. Mujahid, R. Abdalkareem, E. Shihab)
  • Static Race Detection and Mutex Safety and Liveness for Go Programs (J. Gabet, N. Yoshida)
  • EdgeKV: Decentralized, scalable, and consistent storage for the edge (K. Sonbol, Ö. Özkasap, I. Al-Oqily, M. Aloqaily)
  • Bypassing memory safety mechanisms through speculative control flow hijacks (A. Mambretti, A. Sandulescu, A. Sorniotti, W. Robertson, E. Kirda, A. Kurmus)
  • Bounded verification of message-passing concurrency in Go using Promela and Spin (N. Dilley, J. Lange)

2019

  • Software Microbenchmarking in the Cloud. How Bad is it Really?. Laaber, Scheuner, and Leitner. In: Empirical Software Engineering.

  • Understanding Real-World Concurrency Bugs in Go (Tu, Liu, Song, Zhang)

  • An empirical study of messaging passing concurrency in Go projects (N. Dilley, J. Lange)

  • A comparison of three programming languages for a full-fledged next-generation sequencing tool (Costanza, Herzeel, Verachtert)

  • Exploring polyglot software frameworks in ALICE with FairMQ and fer

  • Flash: Efficient Dynamic Routing for Offchain Networks

  • RepChain: A Reputation based Secure, Fast and High Incentive Blockchain System via Sharding

  • Drynx: Decentralized, Secure, Verifiable System for Statistical Queries and Machine Learning on Distributed Datasets

  • STYLE-ANALYZER: fixing code style inconsistencies with interpretable unsupervised algorithms

  • Linear-Time Inference for Pairwise Comparisons with Gaussian-Process Dynamics

2018

  • An Evaluation of Open-Source Software Microbenchmark Suites for Continuous Performance Assessment. Laaber and Leitner. In: MSR ’18: 15th International Conference on Mining Software Repositories.

  • An Analysis of Quorum-based Abstractions: A Case Study using Gorums to Implement Raft. Sebastian Pedersen, Hein Meling, and Leander Jehl. In: Proceedings of the 2018 Workshop on Advanced Tools, Programming Languages, and PLatforms for Implementing and Evaluating Algorithms for Distributed systems, ApPLIED@PODC 2018, Egham, United Kingdom, July 27, 2018. ACM, 2018.

  • Implementation and evaluation of secure and scalable anomaly-based network intrusion detection (P. Mieden)

  • ProIO: An Event-Based I/O Stream Format for Protobuf Messages (D. Blyth, J. Alcaraz, S. Binet, S.V. Chekanov)

  • The latest gossip on BFT consensus (Buchman, Kwon, Milosevic)

  • Distributed Programming using Role-Parametric Session Types in Go (Castro, Hu, Jongmans, NG, Yoshida)

  • Observing the Evolution of QUIC Implementations, (Piraux, De Coninck, Bonaventure)

  • Cody Cutler, M. Frans Kaashoek, and Robert T. Morris, “The benefits and costs of writing a POSIX kernel in a high-level language”

  • Voit, Sebastian Peter Johann. “Writing Network Drivers in Go.”

  • “MoonShine: Optimizing OS Fuzzer Seed Selection with Trace Distillation” (Shankara Pailoor, Andrew Aday, Suman Jana) USENIX Security 2018

  • “Process-Local Static Analysis of Synchronous Processes” (Jan Midtgaard, Flemming Nielson, Hanne Riis Nielson) SAS 2018

  • “Inferring and Asserting Distributed System Invariants” (Stewart Grant, Hendrik Cech, Ivan Beschastnikh) ICSE 2018 Technical Papers

  • “Revisiting the Vector Space Model: Sparse Weighted Nearest-Neighbor Method for Extreme Multi-Label Classification.” (Tatsuhiro Aoshima, Kei Kobayashi, Mihoko Minami) arXiv:1802.03938 stat.ML,

  • A Static Verification Framework for Message Passing in Go using Behavioural Types (J. Lange, N. Ng, B. Toninho, N. Yoshida)

  • Finding The Greedy, Prodigal, and Suicidal Contracts at Scale (Ivica Nikolic, Aashish Kolluri, Ilya Sergey, Prateek Saxena, Aquinas Hobor)

    • pdf “To implement the validating framework, we added a new functionality to the official go-ethereum package [20] which allows us to fork the Ethereum main chain at a block height of our choice.”
  • State of Mutation Testing at Google (Goran Petrovic and Marko Ivankovic)

  • Index Data Structure, Functionality and Microservices in Thematic Virtual Museums (Sajarwo Anggai) (Ph.D. thesis)

  • “Two-Phase Dynamic Analysis of Message-Passing Go Programs based on Vector Clocks” (M. Sulzmann, K. Stadtmueller)

  • “Revisiting the Vector Space Model: Sparse Weighted Nearest-Neighbor Method for Extreme Multi-Label Classification” (Tatsuhiro Aoshima, Kei Kobayashi, Mihoko Minami)

  • “GEEC: Scalable, Efficient, and Consistent Consensus for Blockchains” (Xusheng Chen, Shixiong Zhao, Cheng Wang, Senran Zhang, Heming Cui)

  • “Dependability in a Multi-tenant Multi-framework Deep Learning as-a-Service Platform” (Scott Boag, Parijat Dube, Kaoutar El Maghraoui, Benjamin Herta, Waldemar Hummer, K. R. Jayaram, Rania Khalaf, Vinod Muthusamy, Michael Kalantar, Archit Verma)

  • DRONE: a Distributed Subgraph-Centric Framework for Processing Large Scale Power-law Graphs

  • Reducing Metadata Leakage from Encrypted Files and Communication with PURBs

2017

2016

  • Atom: Horizontally Scaling Strong Anonymity (Albert Kwon, Henry Corrigan-Gibbs, Srinivas Devadas, Bryan Ford)
    • arXiv:1612.07841 cs.CR “...We implemented an Atom prototype in Go in approximately 3,500 lines of code, ...”
  • The Case for Reconfiguration without Consensus: Comparing Algorithms for Atomic Storage (Leander Jehl, Hein Meling)
  • Flower : Workflow management and heat-aware scheduling for modern cloud infrastructures (Robert Carosi, Boris Mattijssen) bachelor thesis,
    • abstract, pdf, Keywords: container, workflow, virtualization, scheduling, flower, kubernetes
  • Implementing a web-based bookingsystem using Go ( Vu, Phi-Long ) Independent thesis Basic level
    • abstract, pdf ; Keywords: Booking System, Go, Golang, REST, XSS, XSRF
  • Parallelization of the corpus manager’s time-consuming operations (Bc. Radoslav Rábara ) Master's Thesis, Masaryk University
    • pdf ; Keywords: Manatee, text corpora, Go, text compression, compression of integers, time-consuming operations, parallelization, MapReduce, Glow, distributed computing, data format, cluster, scalability
  • Cyber Security Exercise Modeling & Tracking (Joonas Greis) Bachelor’s thesis
    • pdf “... RESTful API was written with Golang using Go-Json-Rest package ...”
  • Scalable Byzantine Consensus via Hardware-assisted Secret Sharing (Jian Liu, Wenting Li, Ghassan O. Karame, N. Asokan)
  • Fast and Reliable Byzantine Fault Tolerance (Eric Scott Freeman) Master's thesis in Computer science
  • Formal verification of concurrency in go (Anuchit Prasertsang, Denduang Pradubsuwun)
  • Therapeutic target discovery using Boolean network attractors: updates from kali ( Arnaud Poret ) ( Quantitative Biology > Molecular Networks)
  • Information Flow Analysis for Go ( Eric Bodden, Ka I. Pun, Martin Steffen, Volker Stolz, Anna-Katharina Wickert)
  • A Productivity Checker for Logic Programming (E. Komendantskaya, P. Johann, M. Schmidt )
  • A novel algorithm for detecting multiple covariance and clustering of biological sequences ( Wei Shen & Yan Li) ( Coevolution, Computational models )
  • Architecture of the Hyperledger Blockchain Fabric (Christian Cachin)
  • Reimagining the Programming Experience ( Mehrdad Afshari , dissertation) GoClr
  • MapReduce vs. Pipelining Counting Triangles (Edelmira Pasarella, Maria-Esther Vidal,and Cristina Zoltan)
  • Parametric Polymorphism in the Go Programming Language (Matthew Allen) University of Texas, Turing Scholars honors thesis
  • Static Trace-Based Deadlock Analysis for Synchronous Mini-Go ( Kai Stadtmüller, Martin Sulzmann, and Peter Thiemann )
    • pdf
    • code - first beta implementation : gopherlyzer
  • Continuous Query-Based Syndication: Distributed, Expressive Messaging for the IoT( Gabriel Fierro, Erik Krogen )
  • Privacy, Discovery, and Authentication for the Internet of Things (Wu, Taly, Shankar, Boneh)
  • Static Deadlock Detection for Concurrent Go by Global Session Graph Synthesis (Ng, Yoshida)
  • A Small-Step Semantics of a Concurrent Calculus with Goroutines and Deferred Functions ( Martin Steffen )
  • Butterfield, Ellis H., “Fog Computing with Go: A Comparative Study” (2016). CMC Senior Theses. Paper 1348.
  • An Implementation and Analysis of a Kernel Network Stack in Go with the CSP Style (Harshal Sheth, Aashish Welling)
  • PAS-MC: Privacy-preserving Analytics Stream for the Mobile Cloud (Joy, Gerla)
  • Developing an Ethereum Blockchain Application (Triantafyllidis)
  • Identifying and characterizing Sybils in the Tor network (Winter, Ensafi, Loesing, and Feamster)
  • A Distributed Implementation of the Graph Database System: DGraph
  • Browsix: Bridging the Gap Between Unix and the Browser (Powers, Vilk, Berger)
  • Verification of Goroutines using Why3 (Schoolderman)
  • Detection of Bugs and Code Smells through Static Analysis of Go Source Code (Bergersen)
  • BTrDB: Optimizing Storage System Design for Timeseries Processing (Andersen, Culler)
  • Risk Factor Disclosures: Do Managers and Markets Speak the Same Language?

2015

2014

2013

2012

  • Time Warp on the Go (D'Angelo, Ferretti, Marzolla)
  • Can Go address the multicore issues of today and the manycore problems of tomorrow? (S. Binet)
  • GoCxx: a tool to easily leverage C++ legacy code for multicore-friendly Go libraries and frameworks (S. Binet)
  • The Buffered π-Calculus: A Model for Concurrent Languages (Deng, Zhang, Deng, Zhong)
  • Analysis of the Go runtime scheduler (Neil Deshpande,Erica Sponsler,Nathaniel Weiss)
  • A Comparative Study of Programming Models for Concurrency ( Kaue Soares da Silveira) – Porto Alegre: COMGRAD CIC UFRGS, 2012. Final Report (Bachelor)
  • Debian Code Search (Stapelberg)
  • Go’s Concurrency Constructs on the SCC (Prell, Rauber)
  • Comparing Parallel Performance of Go and C++ TBB on a Direct Acyclic Task Graph Using a Dynamic Programming Problem (Serfass, Tang)

2011

  • ng: What next-generation languages can teach us about HENP frameworks in the manycore era (S. Binet)
  • Serving Web Content with Dynamic Process Networks in Go (James Whitehead II)

2010

  • GoHotDraw: Evaluating the Go Programming Language with Design Patterns (Schmager, Cameron, Noble)