research-article

Open access

The essence of online data processing

Authors:

Kenneth ChiuAuthors Info & Claims

Proceedings of the ACM on Programming Languages, Volume 6, Issue OOPSLA2

Article No.: 157, Pages 899 - 928

https://doi.org/10.1145/3563320

Published: 31 October 2022 Publication History

Abstract

Data processing systems are a fundamental component of the modern computing stack. These systems are routinely deployed online: they continuously receive the requests of data processing operations, and continuously return the results to end users or client applications. Online data processing systems have unique features beyond conventional data processing, and the optimizations designed for them are complex, especially when data themselves are structured and dynamic. This paper describes DON Calculus, the first rigorous foundation for online data processing. It captures the essential behavior of both the backend data processing engine and the frontend application, with the focus on two design dimensions essential yet unique to online data processing systems: incremental operation processing (IOP) and temporal locality optimization (TLO). A novel design insight is that the operations continuously applied to the data can be defined as an operation stream flowing through the data structure, and this abstraction unifies diverse designs of IOP and TLO in one calculus. DON Calculus is endowed with a mechanized metatheory centering around a key observable equivalence property: despite the significant non-deterministic executions introduced by IOP and TLO, the observable result of DON Calculus data processing is identical to that of conventional data processing without IOP and TLO. Broadly, DON Calculus is a novel instance in the active pursuit of providing rigorous guarantees to the software system stack. The specification and mechanization of DON Calculus provide a sound base for the designers of future data processing systems to build upon, helping them embrace rigorous semantic engineering without the need of developing from scratch.

References

[1]

2010. Neo4j Graph Database. http://www.neo4j.org

[2]

Umut A. Acar, Guy E. Blelloch, and Robert Harper. 2006. Adaptive Functional Programming. ACM Trans. Program. Lang. Syst., 28, 6 (2006), Nov., https://doi.org/10.1145/1186632.1186634

Digital Library

[3]

Andrew W. Appel, Lennart Beringer, Adam Chlipala, Benjamin C. Pierce, Zhong Shao, Stephanie Weirich, and Steve Zdancewic. 2016. The DeepSpec Project: The Science of Deep Specification,. https://deepspec.org/

[4]

Arvind Arasu and Jennifer Widom. 2004. A Denotational Semantics for Continuous Queries over Streams and Relations. SIGMOD Rec., 33, 3 (2004), sep, 6–11. issn:0163-5808 https://doi.org/10.1145/1031570.1031572

Digital Library

[5]

E. A. Ashcroft and W. W. Wadge. 1977. Lucid, a nonprocedural language with iteration. Commun. ACM, 20, 7 (1977), July, 8 pages. https://doi.org/10.1145/359636.359715

Digital Library

[6]

Thomas W. Bartenstein and Yu David Liu. 2014. Rate Types for Stream Programs. In OOPSLA’14 (OOPSLA ’14). 213–232. https://doi.org/10.1145/2660193.2660225

Digital Library

[7]

Dimitri P Bertsekas and John N Tsitsiklis. 1989. Parallel and distributed computation: numerical methods. 23, Prentice hall Englewood Cliffs, NJ.

[8]

Sergey Brin and Lawrence Page. 1998. The Anatomy of a Large-Scale Hypertextual Web Search Engine. Computer Networks, 30 (1998), 107–117. https://doi.org/10.1016/S0169-7552(98)00110-X

Digital Library

[9]

Peter Buneman, Susan Davidson, Gerd Hillebrand, and Dan Suciu. 1996. A query language and optimization techniques for unstructured data. In Proceedings of the 1996 ACM SIGMOD international conference on Management of data. 505–516. https://doi.org/10.1145/233269.233368

Digital Library

[10]

Cristiano Calcagno, Walid Taha, Liwen Huang, and Xavier Leroy. 2003. Implementing Multi-Stage Languages Using ASTs, Gensym, and Reflection. In Proceedings of the 2nd International Conference on Generative Programming and Component Engineering (GPCE ’03). Springer-Verlag, 57–76. isbn:3540201025 https://doi.org/10.1007/978-3-540-39815-8_4

[11]

Luca Cardelli. 1988. Phase Distinctions in Type Theory.

[12]

P. Caspi, D. Pilaud, N. Halbwachs, and J. A. Plaice. 1987. LUSTRE: a declarative language for real-time programming. In POPL ’87. 178–188. https://doi.org/10.1145/41625.41641

Digital Library

[13]

Raymond Cheng, Ji Hong, Aapo Kyrola, Youshan Miao, Xuetian Weng, Ming Wu, Fan Yang, Lidong Zhou, Feng Zhao, and Enhong Chen. 2012. Kineograph: Taking the Pulse of a Fast-changing and Connected World. In Proceedings of the 7th ACM European Conference on Computer Systems (EuroSys ’12). ACM, New York, NY, USA. 85–98. isbn:978-1-4503-1223-3 https://doi.org/10.1145/2168836.2168846

Digital Library

[14]

James Cipar, Greg Ganger, Kimberly Keeton, Charles B. Morrey, Craig A.N. Soules, and Alistair Veitch. 2012. LazyBase: Trading Freshness for Performance in a Scalable Database. In Proceedings of the 7th ACM European Conference on Computer Systems (EuroSys ’12). Association for Computing Machinery, New York, NY, USA. 169–182. isbn:9781450312233 https://doi.org/10.1145/2168836.2168854

Digital Library

[15]

Albert Cohen, Marc Duranton, Christine Eisenbeis, Claire Pagetti, Florence Plateau, and Marc Pouzet. 2006. N-Synchronous Kahn Networks: A Relaxed Model of Synchrony for Real-Time Systems. In POPL’06 (POPL ’06). 180–193. https://doi.org/10.1145/1111320.1111054

Digital Library

[16]

Jeffrey Dean and Sanjay Ghemawat. 2004. MapReduce: Simplified Data Processing on Large Clusters. In OSDI’04: Sixth Symposium on Operating System Design and Implementation. San Francisco, CA. 137–150. https://doi.org/10.1145/1327452.1327492

Digital Library

[17]

Philip Dexter, Yu David Liu, and Kenneth Chiu. 2016. Lazy graph processing in Haskell. In Proceedings of the 9th International Symposium on Haskell. 182–192. https://doi.org/10.1145/3241625.2976014

Digital Library

[18]

Philip Dexter, Yu David Liu, and Kenneth Chiu. 2022. The Essence of Online Data Processing - Coq Mechanization. https://doi.org/10.5281/zenodo.7051651

Digital Library

[19]

Laxman Dhulipala, Guy E Blelloch, and Julian Shun. 2019. Low-latency graph streaming using compressed purely-functional trees. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation. 918–934. https://doi.org/10.1145/3314221.3314598

Digital Library

[20]

David Ediger, Rob McColl, Jason Riedy, and David A Bader. 2012. Stinger: High performance data structure for streaming graphs. In 2012 IEEE Conference on High Performance Extreme Computing. 1–5. https://doi.org/10.1109/HPEC.2012.6408680

[21]

Marwa Elteir, Heshan Lin, and Wu-chun Feng. 2010. Enhancing mapreduce via asynchronous data processing. In 2010 IEEE 16th International Conference on Parallel and Distributed Systems. 397–405. https://doi.org/10.1109/ICPADS.2010.116

Digital Library

[22]

Kento Emoto, Kiminori Matsuzaki, Zhenjiang Hu, Akimasa Morihata, and Hideya Iwasaki. 2016. Think like a Vertex, Behave like a Function! A Functional DSL for Vertex-Centric Big Graph Processing. In Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming (ICFP 2016). Association for Computing Machinery, New York, NY, USA. 200–213. isbn:9781450342193 https://doi.org/10.1145/2951913.2951938

Digital Library

[23]

Jeffrey Eymer, Philip Dexter, and Yu David Liu. 2019. Toward Lazy Evaluation in a Graph Database. In The Second Workshop on Incremental Computing (IC’19).

[24]

Jeff Eymer, Philip Dexter, Joseph Raskind, and Yu David Liu. 2022. The PitStop System, online at. https://github.com/PitStop-Github/PitStop

[25]

Cormac Flanagan and Matthias Felleisen. 1995. The Semantics of Future and Its Use in Program Optimizations. In Conference Record of POPL’95: 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, San Francisco, California, USA, January 23-25, 1995, Ron K. Cytron and Peter Lee (Eds.). ACM Press, 209–220. https://doi.org/10.1145/199448.199484

Digital Library

[26]

Cormac Flanagan and Matthias Felleisen. 1999. The Semantics of Future and an Application. J. Funct. Program., 9, 1 (1999), 1–31. http://journals.cambridge.org/action/displayAbstract?aid=44231

Digital Library

[27]

Joseph E. Gonzalez, Yucheng Low, Haijie Gu, Danny Bickson, and Carlos Guestrin. 2012. PowerGraph: Distributed Graph-Parallel Computation on Natural Graphs. In Presented as part of the 10th USENIX Symposium on Operating Systems Design and Implementation (OSDI 12). USENIX, Hollywood, CA. 17–30. isbn:978-1-931971-96-6

[28]

Samuel Grossman, Heiner Litz, and Christos Kozyrakis. 2018. Making Pull-Based Graph Processing Performant. SIGPLAN Not., 53, 1 (2018), Feb., 246–260. issn:0362-1340 https://doi.org/10.1145/3200691.3178506

Digital Library

[29]

Yuri Gurevich, Dirk Leinders, and Jan Van Den Bussche. 2007. A Theory of Stream Queries. In Proceedings of the 11th International Conference on Database Programming Languages (DBPL’07). Springer-Verlag, Berlin, Heidelberg. 153–168. isbn:3540759867 https://doi.org/10.1007/978-3-540-75987-4_11

[30]

Philipp Haller and Heather Miller. 2019. A reduction semantics for direct-style asynchronous observables. J. Log. Algebraic Methods Program., 105 (2019), 75–111. https://doi.org/10.1016/j.jlamp.2019.03.002

[31]

Philipp Haller, Heather Miller, and Normen Müller. 2018. A programming model and foundation for lineage-based distributed computation. JFP, 28 (2018), https://doi.org/10.1017/S0956796818000035

[32]

Robert H. Halstead, Jr. 1985. MULTILISP: a language for concurrent symbolic computation. ACM Trans. Program. Lang. Syst., 7 (1985), 10, 501–538. issn:0164-0925 https://doi.org/10.1145/4472.4478

Digital Library

[33]

Matthew A. Hammer, Khoo Yit Phang, Michael Hicks, and Jeffrey S. Foster. 2014. Adapton: Composable, Demand-driven Incremental Computation. In PLDI ’14. https://doi.org/10.1145/2666356.2594324

Digital Library

[34]

Wentao Han, Youshan Miao, Kaiwei Li, Ming Wu, Fan Yang, Lidong Zhou, Vijayan Prabhakaran, Wenguang Chen, and Enhong Chen. 2014. Chronos: a graph engine for temporal graph analysis. In Proceedings of the Ninth European Conference on Computer Systems. 1–14. https://doi.org/10.1145/2592798.2592799

Digital Library

[35]

Daco C Harkes, Danny M Groenewegen, and Eelco Visser. 2016. IceDust: Incremental and Eventual Computation of Derived Values. In ECOOP ’16. https://doi.org/10.4230/LIPIcs.ECOOP.2016.11

[36]

Daco C Harkes and Eelco Visser. 2017. IceDust 2: Derived Bidirectional Relations and Calculation Strategy Composition. In 31st European Conference on Object-Oriented Programming. https://doi.org/10.4230/LIPIcs.ECOOP.2017.14

[37]

Robert Harper, John C. Mitchell, and Eugenio Moggi. 1989. Higher-Order Modules and the Phase Distinction. In Proceedings of the 17th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’90). 341–354. isbn:0897913434 https://doi.org/10.1145/96709.96744

Digital Library

[38]

Martin Hirzel, Robert Soulé, Scott Schneider, Buğra Gedik, and Robert Grimm. 2014. A Catalog of Stream Processing Optimizations. ACM Comput. Surv., 46, 4 (2014), Article 46, mar, 34 pages. issn:0360-0300 https://doi.org/10.1145/2528412

Digital Library

[39]

Gérard Huet. 1980. Confluent Reductions: Abstract Properties and Applications to Term Rewriting Systems: Abstract Properties and Applications to Term Rewriting Systems. J. ACM, 27, 4 (1980), Oct., 797–821. issn:0004-5411

Digital Library

[40]

Xiaoen Ju, Dan Williams, Hani Jamjoom, and Kang G. Shin. 2016. Version Traveler: Fast and Memory-Efficient Version Switching in Graph Processing Systems. In 2016 USENIX Annual Technical Conference (USENIX ATC 16). USENIX Association, Denver, CO. 523–536. isbn:978-1-931971-30-0

[41]

Pradeep Kumar and H. Howie Huang. 2020. GraphOne: A Data Store for Real-Time Analytics on Evolving Graphs. ACM Trans. Storage, 15, 4 (2020), Article 29, Jan., 40 pages. issn:1553-3077 https://doi.org/10.1145/3364180

Digital Library

[42]

W. Le, A. Kementsietsidis, S. Duan, and F. Li. 2012. Scalable Multi-query Optimization for SPARQL. In 2012 IEEE 28th International Conference on Data Engineering. 666–677. https://doi.org/10.1109/ICDE.2012.37

Digital Library

[43]

E. A. Lee and D. G. Messerschmitt. 1987. Synchronous data flow. Proc. IEEE, 75, 9 (1987), 1235–1245. https://doi.org/10.1109/PROC.1987.13876

[44]

Yu David Liu, Christian Skalka, and Scott F. Smith. 2009. Type-specialized staged programming with process separation. Higher-Order and Symbolic Computation, 24 (2009), 341–385. https://doi.org/10.1145/1596614.1596622

Digital Library

[45]

Yucheng Low, Danny Bickson, Joseph Gonzalez, Carlos Guestrin, Aapo Kyrola, and Joseph M Hellerstein. 2012. Distributed GraphLab: a framework for machine learning and data mining in the cloud. Proceedings of the VLDB Endowment, 5, 8 (2012), 716–727. https://doi.org/10.14778/2212351.2212354

Digital Library

[46]

Grzegorz Malewicz, Matthew H. Austern, Aart J.C Bik, James C. Dehnert, Ilan Horn, Naty Leiser, and Grzegorz Czajkowski. 2010. Pregel: A System for Large-scale Graph Processing. In SIGMOD ’10. 135–146. isbn:978-1-4503-0032-2 https://doi.org/10.1145/1807167.1807184

Digital Library

[47]

Mugilan Mariappan, Joanna Che, and Keval Vora. 2021. DZiG: Sparsity-Aware Incremental Processing of Streaming Graphs. In Proceedings of the Sixteenth European Conference on Computer Systems (EuroSys ’21). Association for Computing Machinery, New York, NY, USA. 83–98. isbn:9781450383349 https://doi.org/10.1145/3447786.3456230

Digital Library

[48]

Mugilan Mariappan and Keval Vora. 2019. GraphBolt: Dependency-Driven Synchronous Processing of Streaming Graphs. In Proceedings of the Fourteenth EuroSys Conference 2019 (EuroSys ’19). Association for Computing Machinery, New York, NY, USA. Article 25, 16 pages. isbn:9781450362818 https://doi.org/10.1145/3302424.3303974

Digital Library

[49]

Leo A. Meyerovich, Arjun Guha, Jacob Baskin, Gregory H. Cooper, Michael Greenberg, Aleks Bromfield, and Shriram Krishnamurthi. 2009. Flapjax: A Programming Language for Ajax Applications. In Proceedings of the 24th ACM SIGPLAN Conference on Object Oriented Programming Systems Languages and Applications (OOPSLA ’09). ACM, New York, NY, USA. 1–20. isbn:978-1-60558-766-0 https://doi.org/10.1145/1640089.1640091

Digital Library

[50]

Ralf Mitschke, Sebastian Erdweg, Mirko Köhler, Mira Mezini, and Guido Salvaneschi. 2014. I3QL: Language-Integrated Live Data Views. In OOPSLA’14. 417–432. https://doi.org/10.1145/2660193.2660242

Digital Library

[51]

Derek G Murray, Frank McSherry, Rebecca Isaacs, Michael Isard, Paul Barham, and Martín Abadi. 2013. Naiad: a timely dataflow system. In Proceedings of the Twenty-Fourth ACM Symposium on Operating Systems Principles. 439–455. https://doi.org/10.1145/2517349.2522738

Digital Library

[52]

Derek G Murray, Malte Schwarzkopf, Christopher Smowton, Steven Smith, Anil Madhavapeddy, and Steven Hand. 2011. CIEL: a universal execution engine for distributed data-flow computing. In Proc. 8th ACM/USENIX Symposium on Networked Systems Design and Implementation. 113–126.

[53]

Kay Ousterhout, Ryan Rasti, Sylvia Ratnasamy, Scott Shenker, and Byung-Gon Chun. 2015. Making Sense of Performance in Data Analytics Frameworks. In 12th USENIX Symposium on Networked Systems Design and Implementation (NSDI 15). USENIX Association, Oakland, CA. 293–307. isbn:978-1-931971-218

Digital Library

[54]

Yannis Papakonstantinou, Hector Garcia-Molina, and Jennifer Widom. 1995. Object exchange across heterogeneous information sources. In Proceedings of the eleventh international conference on data engineering. 251–260. https://doi.org/10.1109/ICDE.1995.380386

[55]

J. Park and A. Segev. 1988. Using common subexpressions to optimize multiple queries. In Proceedings. Fourth International Conference on Data Engineering. 311–319. https://doi.org/10.1109/ICDE.1988.105474

[56]

W. Pugh and T. Teitelbaum. 1989. Incremental Computation via Function Caching. In POPL ’89. https://doi.org/10.1145/75277.75305

Digital Library

[57]

Karthik Ramachandra and S. Sudarshan. 2012. Holistic Optimization by Prefetching Query Results. In Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD ’12). 133–144. isbn:978-1-4503-1247-9

[58]

Xuguang Ren and Junhu Wang. 2016. Multi-Query Optimization for Subgraph Isomorphism Search. Proc. VLDB Endow., 10, 3 (2016), Nov., 121–132. issn:2150-8097 https://doi.org/10.14778/3021924.3021929

Digital Library

[59]

Amitabha Roy, Ivo Mihailovic, and Willy Zwaenepoel. 2013. X-stream: Edge-centric graph processing using streaming partitions. In SOSP ’13. 472–488. https://doi.org/10.1145/2517349.2522740

Digital Library

[60]

Ziv Scully and Adam Chlipala. 2017. A Program Optimization for Automatic Database Result Caching. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL 2017). 271–284. isbn:978-1-4503-4660-3 https://doi.org/10.1145/3009837.3009891

Digital Library

[61]

Timos K. Sellis. 1988. Multiple-Query Optimization. ACM Trans. Database Syst., 13, 1 (1988), March, 23–52. issn:0362-5915 https://doi.org/10.1145/42201.42203

Digital Library

[62]

Timos K. Sellis and Leonard Shapiro. 1985. Optimization of Extended Database Query Languages. In Proceedings of the 1985 ACM SIGMOD International Conference on Management of Data (SIGMOD ’85). Association for Computing Machinery, New York, NY, USA. 424–436. isbn:0897911601 https://doi.org/10.1145/971699.318993

Digital Library

[63]

Feng Sheng, Qiang Cao, Haoran Cai, Jie Yao, and Changsheng Xie. 2018. GraPU: Accelerate Streaming Graph Analysis through Preprocessing Buffered Updates. In Proceedings of the ACM Symposium on Cloud Computing (SoCC ’18). Association for Computing Machinery, New York, NY, USA. 301–312. isbn:9781450360111 https://doi.org/10.1145/3267809.3267811

Digital Library

[64]

Xiaogang Shi, Bin Cui, Yingxia Shao, and Yunhai Tong. 2016. Tornado: A system for real-time iterative analysis over evolving data. In SIGMOD ’16. 417–430. https://doi.org/10.1145/2882903.2882950

Digital Library

[65]

Julian Shun and Guy E. Blelloch. 2013. Ligra: A Lightweight Graph Processing Framework for Shared Memory. In Proceedings of the 18th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’13). Association for Computing Machinery, New York, NY, USA. 135–146. isbn:9781450319225 https://doi.org/10.1145/2442516.2442530

Digital Library

[66]

Robert Soulé, Martin Hirzel, Robert Grimm, Buğra Gedik, Henrique Andrade, Vibhore Kumar, and Kun-Lung Wu. 2010. A Universal Calculus for Stream Processing Languages. In Proceedings of the 19th European Conference on Programming Languages and Systems (ESOP’10). Springer-Verlag, Berlin, Heidelberg. 507–528. isbn:3642119565 https://doi.org/10.1007/978-3-642-11957-6_27

Digital Library

[67]

Marcelo Sousa, Isil Dillig, Dimitrios Vytiniotis, Thomas Dillig, and Christos Gkantsidis. 2014. Consolidation of Queries with User-defined Functions. In Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. 554–564. isbn:978-1-4503-2784-8 https://doi.org/10.1145/2666356.2594305

Digital Library

[68]

Jesper H. Spring, Jean Privat, Rachid Guerraoui, and Jan Vitek. 2007. Streamflex: High-Throughput Stream Programming in Java. In Proceedings of the 22nd Annual ACM SIGPLAN Conference on Object-Oriented Programming Systems and Applications (OOPSLA ’07). Association for Computing Machinery, New York, NY, USA. 211–228. isbn:9781595937865 https://doi.org/10.1145/1297027.1297043

Digital Library

[69]

Nicolas Stucki, Jonathan Immanuel Brachthäuser, and Martin Odersky. 2021. Multi-Stage Programming with Generative and Analytical Macros. In Proceedings of the 20th ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE 2021). Association for Computing Machinery, New York, NY, USA. 110–122. isbn:9781450391122 https://doi.org/10.1145/3486609.3487203

Digital Library

[70]

Toyotaro Suzumura, Shunsuke Nishii, and Masaru Ganse. 2014. Towards Large-Scale Graph Stream Processing Platform. In Proceedings of the 23rd International Conference on World Wide Web (WWW ’14 Companion). Association for Computing Machinery, New York, NY, USA. 1321–1326. isbn:9781450327459 https://doi.org/10.1145/2567948.2580051

Digital Library

[71]

Walid Taha and Tim Sheard. 1997. Multi-Stage Programming with Explicit Annotations. In Proceedings of the 1997 ACM SIGPLAN Symposium on Partial Evaluation and Semantics-Based Program Manipulation (PEPM ’97). 203–217. https://doi.org/10.1145/258993.259019

Digital Library

[72]

Kanat Tangwongsan, Martin Hirzel, Scott Schneider, and Kun-Lung Wu. 2015. General Incremental Sliding-Window Aggregation. Proc. VLDB Endow., 8, 7 (2015), feb, 702–713. issn:2150-8097 https://doi.org/10.14778/2752939.2752940

Digital Library

[73]

William Thies, Michal Karczmarek, and Saman Amarasinghe. 2002. StreamIt: A Language for Streaming Applications. In Compiler Construction, R. Nigel Horspool (Ed.). 2304, Springer Berlin Heidelberg, Berlin, Heidelberg. 179–196. isbn:978-3-540-45937-8

Digital Library

[74]

Mandana Vaziri, Olivier Tardieu, Rodric Rabbah, Philippe Suter, and Martin Hirzel. 2014. Stream Processing with a Spreadsheet. In ECOOP 2014 – Object-Oriented Programming, Richard Jones (Ed.). Springer Berlin Heidelberg, Berlin, Heidelberg. 360–384. isbn:978-3-662-44202-9 https://doi.org/10.1007/978-3-662-44202-9_15

Digital Library

[75]

Venkateshwaran Venkataramani, Zach Amsden, Nathan Bronson, George Cabrera III, Prasad Chakka, Peter Dimov, Hui Ding, Jack Ferris, Anthony Giardullo, Jeremy Hoon, Sachin Kulkarni, Nathan Lawrence, Mark Marchukov, Dmitri Petrov, and Lovro Puzar. 2012. TAO: How Facebook Serves the Social Graph. In Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD ’12). ACM, New York, NY, USA. 791–792. isbn:978-1-4503-1247-9 https://doi.org/10.1145/2213836.2213957

Digital Library

[76]

Keval Vora, Rajiv Gupta, and Guoqing Xu. 2017. KickStarter: Fast and Accurate Computations on Streaming Graphs via Trimmed Approximations. In ASPLOS ’17. 237–251. isbn:978-1-4503-4465-4 https://doi.org/10.1145/3037697.3037748

Digital Library

[77]

Guozhang Wang, Wenlei Xie, Alan J Demers, and Johannes Gehrke. 2013. Asynchronous Large-Scale Graph Processing Made Easy. In CIDR. 13, 3–6.

[78]

Kai Wang, Guoqing Xu, Zhendong Su, and Yu David Liu. 2015. GraphQ: Graph Query Processing with Abstraction Refinement— Scalable and Programmable Analytics over Very Large Graphs on a Single PC. In 2015 USENIX Annual Technical Conference (USENIX ATC 15). USENIX Association, Santa Clara, CA. 387–401. isbn:978-1-931971-225

[79]

Yangzihao Wang, Andrew Davidson, Yuechao Pan, Yuduo Wu, Andy Riffel, and John D. Owens. 2016. Gunrock: A High-Performance Graph Processing Library on the GPU. In Proceedings of the 21st ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP ’16). Article 11, 12 pages. https://doi.org/10.1145/2851141.2851145

Digital Library

[80]

Matei Zaharia, Tathagata Das, Haoyuan Li, Timothy Hunter, Scott Shenker, and Ion Stoica. 2013. Discretized Streams: Fault-Tolerant Streaming Computation at Scale. In Proceedings of the Twenty-Fourth ACM Symposium on Operating Systems Principles (SOSP ’13). Association for Computing Machinery, New York, NY, USA. 423–438. isbn:9781450323888 https://doi.org/10.1145/2517349.2522737

Digital Library

[81]

Matei Zaharia, Reynold S. Xin, Patrick Wendell, Tathagata Das, Michael Armbrust, Ankur Dave, Xiangrui Meng, Josh Rosen, Shivaram Venkataraman, Michael J. Franklin, Ali Ghodsi, Joseph Gonzalez, Scott Shenker, and Ion Stoica. 2016. Apache Spark: A Unified Engine for Big Data Processing. Commun. ACM, 59, 11 (2016), Oct., 56–65. issn:0001-0782 https://doi.org/10.1145/2934664

Digital Library

[82]

Kaiyuan Zhang, Rong Chen, and Haibo Chen. 2015. NUMA-Aware Graph-Structured Analytics. In Proceedings of the 20th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP 2015). 183–193.

Digital Library

Cited By

Eymer JDexter PRaskind JLiu Y(2024)A Runtime System for Interruptible Query Processing: When Incremental Computing Meets Fine-Grained ParallelismProceedings of the ACM on Programming Languages10.1145/36897728:OOPSLA2(1729-1756)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689772
Cutler JWatson CNkurumeh EHilliard PGoldstein HStanford CPierce B(2024)Stream TypesProceedings of the ACM on Programming Languages10.1145/36564348:PLDI(1412-1436)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656434

Index Terms

The essence of online data processing
1. Information systems
  1. Data management systems
    1. Database design and models
2. Theory of computation
  1. Semantics and reasoning
    1. Program semantics
      1. Operational semantics

Recommendations

Nominal Recursors as Epi-Recursors

We study nominal recursors from the literature on syntax with bindings and compare them with respect to expressiveness. The term "nominal" refers to the fact that these recursors operate on a syntax representation where the names of bound variables ...
An essence of SSReflect
CICM'12: Proceedings of the 11th international conference on Intelligent Computer Mathematics

SSReflect is a powerful language for proving theorems in the Coq system. It has been used for some of the largest proofs in formal mathematics thus far. However, although it constructs proofs in a formal system, like most other proof languages the ...
Formal verification of higher-order probabilistic programs: reasoning about approximation, convergence, Bayesian inference, and optimization

Probabilistic programming provides a convenient lingua franca for writing succinct and rigorous descriptions of probabilistic models and inference tasks. Several probabilistic programming languages, including Anglican, Church or Hakaru, derive their ...

Comments

Information & Contributors

Information

Published In

cover image Proceedings of the ACM on Programming Languages

Proceedings of the ACM on Programming Languages Volume 6, Issue OOPSLA2

October 2022

1932 pages

EISSN:2475-1421

DOI:10.1145/3554307

Editor:
Philip Wadler
University of Edinburgh, UK

Issue’s Table of Contents

Copyright © 2022 Owner/Author.

This work is licensed under a Creative Commons Attribution 4.0 International License.

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 31 October 2022

Published in PACMPL Volume 6, Issue OOPSLA2

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Badges

Artifacts Available / v1.1

Author Tags

Qualifiers

Research-article

Funding Sources

NSF

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

2
Total Citations
View Citations
368
Total Downloads

Downloads (Last 12 months)148
Downloads (Last 6 weeks)27

Reflects downloads up to 09 Nov 2024

Other Metrics

View Author Metrics

Citations

Cited By

Eymer JDexter PRaskind JLiu Y(2024)A Runtime System for Interruptible Query Processing: When Incremental Computing Meets Fine-Grained ParallelismProceedings of the ACM on Programming Languages10.1145/36897728:OOPSLA2(1729-1756)Online publication date: 8-Oct-2024
https://dl.acm.org/doi/10.1145/3689772
Cutler JWatson CNkurumeh EHilliard PGoldstein HStanford CPierce B(2024)Stream TypesProceedings of the ACM on Programming Languages10.1145/36564348:PLDI(1412-1436)Online publication date: 20-Jun-2024
https://dl.acm.org/doi/10.1145/3656434

View Options

View options

PDF

View or Download as a PDF file.

eReader

View online with eReader.

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Full Access

Get this Article

Media

Figures

Other

Tables

View Issue’s Table of Contents