Bibliography

  1. Algehed, Maximilian, and Patrik Jansson. “VisPar: Visualising dataflow graphs from the Par monad.” (2017).

  2. Andersson, Oscar, and Jin, Yanling. “A Tutorial on Parallel Strategies in Haskell”, 2014.

  3. Ankner, Johan, and Josef David Svenningsson. “An EDSL approach to high performance Haskell programming.” ACM SIGPLAN Notices. Vol. 48. No. 12. ACM, 2013.

  4. Aswad, M. KH, and Philip W. Trinder. “Architecture aware parallel programming in Glasgow Parallel Haskell (GPH).” Procedia Computer Science 9 (2012): 1807-1816.

  5. Armbrust, Michael, et al. Above the clouds: A berkeley view of cloud computing. Vol. 17. Technical Report UCB/EECS-2009-28, EECS Department, University of California, Berkeley, 2009.

  6. Aswad, M. KH, and Philip W. Trinder. “Architecture aware parallel programming in Glasgow Parallel Haskell (GPH).” Procedia Computer Science 9 (2012): 1807-1816.

  7. Bekki, Daisuke, and Ai Kawazoe. “Implementing Variable Vectors in a CCG Parser.” International Conference on Logical Aspects of Computational Linguistics. Springer, Berlin, Heidelberg, 2016.

  8. Bird, Richard. “Thinking functionally with Haskell”. Cambridge University Press, 2014.

  9. Bu, Yingyi, et al. “HaLoop: Efficient iterative data processing on large clusters.” Proceedings of the VLDB Endowment 3.1-2 (2010): 285-296.

  10. Burke, John. “A Haskell Implementation of MapReduce.”

  11. Cavalheiro, Gerson GH, and Renata HS Reiser. “Concurrent Hash Tables for Haskell.” Programming Languages: 20th Brazilian Symposium, SBLP 2016, Maringá, Brazil, September 22-23, 2016, Proceedings. Vol. 9889. Springer, 2016.

  12. Chen, Hsinchun, Roger HL Chiang, and Veda C. Storey. “Business intelligence and analytics: From big data to big impact.” MIS quarterly 36.4 (2012).

  13. Chen, Yu-Fang, et al. “An executable sequential specification for Spark aggregation.” International Conference on Networked Systems. Springer, Cham, 2017.

  14. Church, James. “Learning Haskell Data Analysis”. Packt Publishing Ltd, 2015.

  15. Dean, Jeffrey, and Sanjay Ghemawat. “MapReduce: simplified data processing on large clusters.” Communications of the ACM 51.1 (2008): 107-113.

  16. Dean, Jeffrey, and Sanjay Ghemawat. “MapReduce: a flexible data processing tool.” Communications of the ACM 53.1 (2010): 72-77.

  17. Dittrich, Jens, and Jorge-Arnulfo Quiané-Ruiz. “Efficient big data processing in Hadoop MapReduce.” Proceedings of the VLDB Endowment 5.12 (2012): 2014-2015.

  18. Doets, H. C., and Jan Eijck. “The Haskell road to logic, maths and programming.” Texts in Computing (2012).

  19. Duarte, Rodrigo Medeiros, et al. “Concurrent Hash Tables for Haskell.” Brazilian Symposium on Programming Languages. Springer, Cham, 2016.

  20. Ekanayake, Jaliya, et al. “Twister: a runtime for iterative mapreduce.” Proceedings of the 19th ACM international symposium on high performance distributed computing. ACM, 2010.

  21. Epstein, Jeff, Andrew P. Black, and Simon Peyton-Jones. “Towards Haskell in the cloud.” ACM SIGPLAN Notices. Vol. 46. No. 12. ACM, 2011.

  22. Fischer, Christian. “Haskell vs. JavaScript for Game Programming.” USCCS 2017: 55.

  23. Fritsch, Joerg. Functional Programming Languages in Computing Clouds. Diss. Cardiff University, 2016.

  24. Gantz, John, and David Reinsel. “The digital universe in 2020: Big data, bigger digital shadows, and biggest growth in the far east.” IDC iView: IDC Analyze the future 2007.2012 (2012): 1-16.

  25. Glushenkov, Mikhail. “A Cross-Platform Scalable I/O Manager for GHC: Improving Haskell Networking on Windows.” (2016).

  26. Hage, Jurriaan. “Haskell in the Large.” (2013).

  27. Haven, Drew, and Eric Stratmann. “Web-based Data Analytics in Haskell.”

  28. Hayes, Brian. “Cloud computing.” Communications of the ACM 51.7 (2008): 9-11.

  29. Hinze, Ralf, Johan Jeuring, and Andres Löh. “Comparing approaches to generic programming in Haskell.” Datatype-Generic Programming. Springer, Berlin, Heidelberg, 2007. 72-149.

  30. Holmes, Alex. Hadoop in practice. Manning Publications Co., 2012.

  31. Hutton, Graham. Programming in Haskell. Cambridge University Press, 2016.

  32. Jain, Akshat, and Megha Gupta. “Evolution and Adoption of programming languages.” Evolution 5.1 (2017).

  33. John Walker, Saint. “Big data: A revolution that will transform how we live, work, and think.” (2014): 181-183.

  34. Jones, Simon Peyton, Andrew Gordon, and Sigbjorn Finne. “Concurrent haskell.” POPL. Vol. 96. 1996.

  35. Jost, Steffen, et al. “Type-Based Cost Analysis for Lazy Functional Languages.” Journal of Automated Reasoning 59.1 (2017): 87-120.

  36. Juchli, Marc, et al. “Mining motivated trends of usage of Haskell libraries.” Proceedings of the 1st International Workshop on API Usage and Evolution. IEEE Press, 2017.

  37. Kusakabe, Shigeru, and Yuuki Ikuta. “Large Scale Random Testing with QuickCheck on MapReduce Framework.” Functional and (Constraint) Logic Programming: 131.

  38. Lai, Longbin, et al. “ShmStreaming: A shared memory approach for improving Hadoop streaming performance.” Advanced Information Networking and Applications (AINA), 2013 IEEE 27th International Conference on. IEEE, 2013.

  39. Lämmel, Ralf. “Google’s MapReduce programming model—Revisited.” Science of computer programming 70.1 (2008): 1-30.

  40. Lemmer, Ryan. Haskell Design Patterns. Packt Publishing Ltd, 2015.

  41. Lima, Luís Gabriel Nunes Ferreira. “Understanding the energy Behavior of concurrent haskell programs.” (2016).

  42. Lindley, Sam, and Conor McBride. “Hasochism: the pleasure and pain of dependently typed Haskell programming.” ACM SIGPLAN Notices 48.12 (2014): 81-92.

  43. Lipovaca, Miran. Learn you a haskell for great good!: a beginner’s guide. no starch press, 2011.

  44. Liu, Lei, et al. “An abstract description method of map-reduce-merge using Haskell.” Mathematical Problems in Engineering 2013 (2013).

  45. Liu, Yu, Zhenjiang Hu, and Kiminori Matsuzaki. “Towards systematic parallel programming over mapreduce.” Euro-Par 2011 Parallel Processing (2011): 39-50.

  46. Lohr, Steve. “The age of big data.” New York Times 11.2012 (2012).1

  47. Logothetis, Dionysios, et al. “Stateful bulk processing for incremental analytics.” Proceedings of the 1st ACM symposium on Cloud computing . ACM, 2010.

  48. Low, Yucheng, et al. “Graphlab: A new framework for parallel machine learning.” arXiv preprint arXiv:1408.2041 (2014).

  49. Manyika, James, et al. “Big data: The next frontier for innovation, competition, and productivity.” (2011).

  50. Marin, Mircea. “Advanced features of Functional Programming (Haskell).” (2017).

  51. Marlow, Simon. “Parallel and concurrent programming in Haskell.” Central European Functional Programming School. Springer Berlin Heidelberg, 2012. 339-401

  52. Marlow, Simon. “Parallel and concurrent programming in Haskell: Techniques for multicore and multithreaded programming”. “ O’Reilly Media, Inc.”, 2013.

  53. Marlow, Simon, et al. “Asynchronous exceptions in Haskell.” Acm sigplan notices. Vol. 36. No. 5. ACM, 2001.

  54. Marlow, Simon, et al. “A lightweight interactive debugger for haskell.” Proceedings of the ACM SIGPLAN workshop on Haskell workshop. ACM, 2007.

  55. Maurer, Luke, et al. “Compiling without continuations.” Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM, 2017.

  56. Mazumder, Mark, and Timothy Braje. “Safe Client/Server Web Development with Haskell.” Cybersecurity Development (SecDev), IEEE. IEEE, 2016.

  57. McAfee, Andrew, and Erik Brynjolfsson. “Big data: the management revolution.” Harvard business review 90.10 (2012): 60-68.

  58. Mell, Peter, and Tim Grance. “The NIST definition of cloud computing.” (2011).

  59. Mena, Alejandro Serrano. “Time Traveling with Haskell.” Beginning Haskell. Apress, 2014. 391-392.

  60. Najd, Shayan, and Simon Peyton Jones. “Trees that Grow.” J. UCS 23.1 (2017): 42-62.

  61. O’Driscoll, Aisling, Jurate Daugelaite, and Roy D. Sleator. “‘Big data’, Hadoop and cloud computing in genomics.” Journal of biomedical informatics 46.5 (2013): 774-781.

  62. O’Sullivan, Bryan, John Goerzen, and Donald Bruce Stewart. Real world haskell: Code you can believe in. ” O’Reilly Media, Inc.”, 2008.

  63. Paykin, Jennifer, and Steve Zdancewic. “The Linearity Monad.” (2017).

  64. Pelletier, Francis Jeffry. “The principle of semantic compositionality.” Topoi 13.1 (1994): 11-24.

  65. Qian, Ling, et al. “Cloud computing: An overview.” Cloud computing (2009): 626-631.

  66. Ranger, Colby, et al. “Evaluating mapreduce for multi-core and multiprocessor systems.” High Performance Computer Architecture, 2007. HPCA 2007. IEEE 13th International Symposium on. Ieee, 2007.

  67. Ribeiro, Rodrigo, et al. “Optional Type Classes for Haskell.” Brazilian Symposium on Programming Languages. Springer International Publishing, 2016.

  68. Ryzhov, Pavel. Haskell Financial Data Modeling and Predictive Analytics. Packt Publishing Ltd, 2013.

  69. Rubio, Fernando, et al. “A Parallel Swarm Library Based on Functional Programming.” International Work-Conference on Artificial Neural Networks. Springer, Cham, 2017.

  70. Schlatt, S., et al. “The Holumbus distributed computing framework & MapReduce in Haskell.” (2009).

  71. Schmidt, Douglas C., and Tim Harrison. “Double-checked locking-an optimization pattern for efficiently initializing and accessing thread-safe objects.” (1997).

  72. Snoyman, Michael. Developing web applications with Haskell and Yesod. ” O’Reilly Media, Inc.”, 2012.

  73. Subashini, Subashini, and Veeraruna Kavitha. “A survey on security issues in service delivery models of cloud computing.” Journal of network and computer applications 34.1 (2011): 1-11.

  74. Takuya, Matsumoto, and Matsuzaki Kiminori. “Evaluation of Libraries for Parallel Computing in Haskell—A Case Study with a Super-resolution Application.” 情報処理学会論文誌プログラミング (PRO) 10.2 (2017).

  75. Tate, Bruce A. Seven languages in seven weeks: a pragmatic guide to learning programming languages. Pragmatic Bookshelf, 2010.

  76. Thompson, Martin, et al. Disruptor. Tech. Rep., May, 2011.

  77. Thomasson, Samuli. “Haskell High Performance Programming”. Packt Publishing, 2016.

  78. Thompson, Martin, et al. “High performance alternative to bounded queues for exchanging data between concurrent threads.” technical paper, LMAX Exchange (2011).

  79. Thompson, Martin, et al. “Disruptor: High performance alternative to bounded queues for exchanging data between concurrent threads.” Technical paper. LMAX, May (2011): 206.

  80. Vasconcellos, Cristiano. “Optional Type Classes for Haskell.” Programming Languages: 20th Brazilian Symposium, SBLP 2016, Maringá, Brazil, September 22-23, 2016, Proceedings. Vol. 9889. Springer, 2016.

  81. Vassena, Marco. “A Verified Information-Flow Control Library.” (2017).

  82. Vassena, Marco, Joachim Breitner, and Alejandro Russo. “Securing Concurrent Lazy Programs.” Security Principles and Trust Hotspot 2017 (2017).

  83. Vassena, Marco, Joachim Breitner, and Alejandro Russo. “Securing Concurrent Lazy Programs Against Information Leakage.” Proceedings of the 30th IEEE Computer Security Foundations Symposium (CSF), 2017.

  84. Vazou, Niki, and Ranjit Jhala. “Refinement Reflection (or, how to turn your favorite language into a proof assistant using SMT).” arXiv preprint arXiv:1610.04641 (2016).

  85. Vlissides, John, et al. “Design patterns: Elements of reusable object-oriented software.” Reading: Addison-Wesley 49.120 (1995): 11.

  86. Viera, Marcos, S. Doaitse Swierstra, and Wouter Swierstra. “Attribute grammars fly first-class: how to do aspect oriented programming in Haskell.” ACM Sigplan Notices. Vol. 44. No. 9. ACM, 2009.

  87. Vollmer, Michael, et al. “SC-Haskell: Sequential Consistency in Languages That Minimize Mutable Shared Heap.” Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. ACM, 2017.

  88. Vossen, J. J. Offloading Haskell functions onto an FPGA. MS thesis. University of Twente, 2016.

  89. Winograd-Cort, D. A. N. I. E. L., Hengchu Zhang, and Benjamin C. Pierce. “Partial Evaluation for Typechecking.”

  90. Wu, Xindong, et al. “Data mining with big data.” IEEE transactions on knowledge and data engineering 26.1 (2014): 97-107.

  91. Yang, Hung-chih, et al. “Map-reduce-merge: simplified relational data processing on large clusters.” Proceedings of the 2007 ACM SIGMOD international conference on Management of data. ACM, 2007.

  92. Yates, Ryan, and Michael L. Scott. “Improving Haskell STM Performance.”

  93. Zhang, Qi, Lu Cheng, and Raouf Boutaba. “Cloud computing: state-of-the-art and research challenges.” Journal of internet services and applications 1.1 (2010): 7-18.

  94. Zhang, Yanfeng, et al. “I2mapreduce: Incremental mapreduce for mining evolving big data.” IEEE transactions on knowledge and data engineering 27.7 (2015): 1906-1919.

  95. Zikopoulos, Paul, and Chris Eaton. Understanding big data: Analytics for enterprise class hadoop and streaming data. McGraw-Hill Osborne Media, 2011.

  96. Abrahamson, Joseph. “A Little Lens Starter Tutorial”, https://www.schoolofhaskell.com/school/to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial

  97. Andersson, Oscar and Jin, Yanling.“A tutorial on Parallel Strategies in Haskell”, http://www.cse.chalmers.se/edu/year/2014/course/DAT280_Parallel_Functional_Programming/Papers/strategies-tutorial-v2.pdf

  98. Apfelmus, Heinrich. “How Lazy Evaluation Works in Haskell”, https://hackhands.com/lazy-evaluation-works-haskell

  99. Chiang, Derek. “Haskell-Page-Rank”, https://github.com/derekchiang/Haskell-Page-Rank/blob/master/pagerank.hs

  100. de Vries, Edsko. “Communication Patterns in Cloud Haskell (Part 3)” http://www.well-typed.com/blog/2012/10/communication-patterns-in-cloud-haskell-part-3/

  101. de Vries, Edsko. “Communication Patterns in Cloud Haskell (Part 4)”, http://www.well-typed.com/blog/many-10-74

  102. Freeman, Phil. “Haskell on Azure”, http://blog.functorial.com/posts/2012-04-29-Haskell-On-Azure.html

  103. Goldberg, Drew. “Executive Summary: Balking Design Patterns”, https://www.cs.colorado.edu/~kena/classes/5828/s12/presentation-materials/goldbergdrew.pdf

  104. Marlow, Simon. “Sample geturls.hs”, https://github.com/simonmar/parconc-examples/blob/master/geturlscancel.hs

  105. Marlow, Simon. “Parallel and Concurrent Haskell Part II”, http://slidegur.com/doc/3167714/parallel-and-concurrent-haskell-part-ii

  106. Marlow, Simon, et al. “A lightweight interactive debugger for haskell.” Proceedings of the ACM SIGPLAN workshop on Haskell workshop. ACM, 2007.

  107. Marlow, Simon. “Parallel & Concurrent Haskell 3: Concurrent Haskell”, http://community.haskell.org/~simonmar/slides/cadarache2012/3%20-%20concurrent%20haskell.pdf

  108. Mestanogullari, Alp, and Boespflug, Mathieu. “Haskell meets large scale distributed analytics”, http://www.tweag.io/posts/2016-02-25-hello-sparkle.html

  109. Sakr, Majd F., Rehman, Suhail and Hammoud, Mohammad. “Dryad and GraphLab. Lecture 11”

  110. Stewart, Don. “Haskell in the large”. Google Tech Talks, 2015.

  111. Tibell, Johan. “The design of the Strict Haskell pragma”, http://blog.johantibell.com/2015/11/the-design-of-strict-haskell-pragma.html

  112. Turoff, Adam. “Design Patterns in Haskell: bracket”, 2007, http://notes-on-haskell.blogspot.ro/2007/03/design-patterns-in-haskell-bracket.html

  113. “ACID (atomicity, consistency, isolation, and durability)”, http://searchsqlserver.techtarget.com/definition/ACID

  114. “Cloud Haskell”, http://haskell-distributed.github.io

  115. “Conquering Hadoop with Haskell and Ozgun Ataman”, https://vimeo.com/90189610

  116. “Control.Concurrent.Chan”, https://hackage.haskell.org/package/base-4.9.1.0/docs/Control-Concurrent-Chan.html

  117. “Data-parallel-Haskell”, https://wiki.haskell.org/GHC/Data_Parallel_Haskell

  118. “Design Patterns”, https://en.wikipedia.org/wiki/Design_Patterns

  119. “Evaluation Strategy”, https://en.wikipedia.org/wiki/Evaluation_strategy

  120. “GenBank Overview”, https://www.ncbi.nlm.nih.gov/genbank

  121. “GHC Language Features”, https://downloads.haskell.org/~ghc/7.0.3/docs/html/users_guide/lang-parallel.html

  122. “haskell-barrier/examples/MatrixMultiplication.hs”, https://github.com/aartamonau/haskell-barrier/blob/master/examples/MatrixMultiplication.hs

  123. “haskell-distributed/distributed-process”, https://github.com/haskell-distributed/distributed-process

  124. “Haskell-MapReduce”, https://git://github.com/Julianporter/Haskell-MapReduce.git

  125. “Introduction to optics: lenses and prisms”, https://medium.com/@gcanti/introduction-to-optics-lenses-and-prisms-3230e73bfcfe

  126. “haskell_hadoop”, https://github.com/paulgb/haskell_hadoop

  127. “Haskell Lenses Notes”, https://rafal.io/posts/haskell-lenses-notes.html

  128. “Haskell-page-rank”, https://github.com/derekchiang/Haskell-Page-Rank/blob/master/pagerank.hs

  129. “krapsh/kraps-haskell”, https://github.com/krapsh/kraps-haskell

  130. “Performance/Data types”, https://wiki.haskell.org/Performance/Data_types

  131. “simonmar/parconc-examples”, https://github.com/simonmar/parconc-examples/blob/master/geturlscancel.hs

  132. “Soostone/hadron”, https://github.com/Soostone/hadron

  133. “Testing Haskell with QuickCheck”, http://jasani.org/2008/01/03/testing-haskell-with-quickcheck

  134. “The network-transport package”, http://hackage.haskell.org/package/network-transport

  135. “ThreadPool.hs”, https://gist.github.com/NicolasT/4163407

  136. “Types of Program Errors”, http://www.inf.unibz.it/~calvanese/teaching/ip/lecture-notes/uni10/node2.html

  137. “xmonad”, http://xmonad.org

  138. “zeromq-haskell”, https://gitlab.com/twittner/zeromq-haskell

Index

A

  1. Ad hoc polymorphism

  2. Arithmetic operators

  3. Asynchronous exceptions

    1. bracket function

    2. cancel operation

    3. CAS operation

    4. channels

    5. forkIO

    6. getMaskingState

    7. IO monad

    8. loop function

    9. mask

    10. putMvar

    11. readMVar

    12. restore function

    13. takeMVar

    14. ThreadId

    15. throwTo

    16. web pages

  4. Atomic blocks

  5. Atomicity, consistency, isolation, and durability (ACID) properties

  6. Automatic resource management

B

  1. Balking pattern

  2. Big data

    1. cleaning

    2. Cloudera

    3. data mining

    4. debugging techniques

SeeDebugging techniques

  1. definition

  2. Hadoop

  3. MongoDB

  4. petabyte

  5. supporting languages for

  6. Talend

  7. 5Vs

  1. Boolean algebra

  2. bracket function

C

  1. Cloud computing

    1. basic steps

    2. characteristic

  2. Cloud Haskell programming

    1. characteristics

    2. client-server example

    3. fault tolerance

    4. first node, creating

    5. generic processes

    6. matching without blocking

      1. hiding implementation details

      2. unexpected messages

    7. messages to processes

    8. messages within channels

      1. input (control) channels

      2. reply channels

    9. monad transformer stack

    10. obtaining information

    11. process lifetime

    12. receiving and matching

    13. serialization

    14. starting and locating processes

    15. topologies

  3. Cluster system

  4. Column-oriented databases

  5. Compare-and-switch (CAS) operation

  6. Concrete event handler

  7. Concurrency design patterns

    1. accuracy

    2. advantages

    3. asynchronous method

    4. balking pattern

    5. barrier

    6. blocks creation

    7. components

    8. configuration

    9. disruptor

    10. double-checked locking

    11. execution

    12. guarded suspension pattern

    13. Haskell

    14. implementation

    15. integrator object

    16. Java code

    17. monitor object

    18. reactor pattern

    19. scheduler pattern

    20. thread pool

    21. trapeze method

  8. Concurrent network servers

  9. Conduits

  10. Constant applicative form (CAF)

  11. C++ programming language

D

  1. DataCleaner tool

  2. Data Parallel Haskell (DPH)

  3. Data processing techniques

  4. Data science

    1. Haskell vs.

    2. overview

    3. vector library

  5. Data storage

  6. Data types

  7. Debugging techniques

    1. accessibility

    2. breakpoint

    3. challenges

    4. development account

    5. displayNote

    6. edmString helper

    7. error message

    8. getResumeContext

    9. GHC API

    10. GHCi

    11. Happstack web server

    12. Hat

    13. Hoed

    14. infinite loops

    15. laziness strategy

    16. Maybe-valued function

    17. mismatched run-time error

    18. new note

    19. parse errors

    20. Printf

    21. queryEntity

    22. root function

    23. safe library

    24. software development

    25. source-located errors

    26. stack trace

    27. tick technique

    28. web application

  8. Disruptor pattern

  9. Divide-and-conquer approach

  10. Document-oriented databases

  11. Double-checked locking

E

  1. Eager evaluation

  2. Empty list

  3. Error function

    1. Either

    2. Fibonacci series

    3. head and tail

    4. infinite list

    5. Maybe function

    6. tail versions

    7. zero error

  4. Eval monad

    1. fct function

    2. rpar function

    3. rseq function

    4. thunk

  5. Evaluation process

    1. eager evaluation

    2. graph reduction

    3. lazy evaluation

    4. logicalAnd function

    5. normal form

    6. redex

    7. reduction rule

    8. thunk

    9. unevaluated expression

    10. upSquare function

    11. WHNF

  6. Event handler

  7. Exceptions

    1. asynchronous

SeeAsynchronous exceptions

  1. dynamic

  2. input/output

  3. lazy evaluation

  4. print function

  5. SqlException

  6. System.IO.Error

  7. try function

F

  1. Fibonacci numbers

  2. filter functions

  3. Finite maps

  4. First In, First Out (FIFO)

  5. Foreign Function Interface (FFI)

  6. Frege’s principle

  7. Functional programming (FP) language vs . OOP

G

  1. Generalized algebraic data types approach

  2. getMax function

  3. Glasgow Parallel Haskell (GPH)

  4. Guarded suspension pattern

  5. Guards

H

  1. Hadoop

    1. components

    2. vs . HaLoop

    3. Haskell-Hadoop library

    4. MapReduce

    5. slaves

    6. stages

    7. streaming

  2. Hadoop Distributed File System (HDSF)

  3. Hadron

    1. ByteString

    2. characteristics

    3. conduit

    4. lens

    5. MapReduce

    6. modules

    7. out-of-the-box protocols

    8. structure

    9. Tap protocol

    10. type function

  4. HaLoop

    1. AddInvariantTable function

    2. AddStepInput function

    3. clusters

    4. Hadoop vs .

    5. inter-iteration locality

    6. iterative application

    7. ResultDistance function

    8. SetFixedPointThreshold function

    9. SetIterationInput function

    10. SetMaxNumOfIterations function

    11. task scheduler

  5. handle function

  6. Haskell

    1. astronomy

    2. biology

    3. biomedical data

    4. cloud module

    5. concurrency

    6. database technology

    7. data collection

    8. data from companies

    9. data generation

    10. data science

    11. data storage

    12. evaluation strategy

    13. Haskell-Hadoop library

    14. history

    15. IoT data

    16. k-means

    17. lazy

    18. local declarations

    19. MapReduce

    20. models

    21. non-strictness

    22. physics

    23. reduction strategy

    24. refactor

    25. runtime system

    26. static type system

    27. StrictData pragmas

    28. Strict pragmas

    29. strong type system

    30. tools

    31. UNPACK pragma

  7. Higher order functions

  8. Hoed

  9. hspark

I, J

  1. IBM SPSS Modeler

  2. Identity monad

  3. if-else statement

  4. Immutable arrays

  5. Improved streaming model

  6. Incremental iterative processing

  7. Infinite list

  8. Infinite loops

  9. Infix notation

  10. Input/output (IO) mechanisms

    1. let statement

    2. :main command

    3. multiple line statements

    4. :run commands

    5. step-by-step translation

    6. temporary binds

  11. Instance declarations, rules for

    1. context

    2. head

    3. instance termination

  12. Inter-iteration locality

  13. International Business Machines (IBM)

  14. Internet of Things (IoT)

  15. Iterative computation, MapReduce

  16. Iterative techniques

    1. algorithm

    2. data flows

    3. implementation

    4. PageRank algorithm

    5. synchronous algorithms

    6. update functions

K

  1. Key-valued databases

  2. k-means

  3. Krapsh library

L

  1. Lambdas

  2. Large-scale design

    1. concurrency

    2. FFIs

    3. monads for structuring

    4. parallelism

    5. purity

    6. refactor

    7. space profiling

    8. time profiling

    9. type classes

    10. type system

  3. Lazy evaluation

  4. Lists

    1. comprehension

    2. concatenation

    3. empty list

    4. vs. parallel arrays

    5. rule

    6. strings

  5. Logical error

M

  1. map function

  2. Map-Reduce Bipartite Graph (MRBGraph)

  3. MapReduce programming model

    1. backup execution

    2. cluster system

    3. data processing techniques

    4. fault tolerance

    5. Hadoop

    6. Hadron

    7. Haskell

    8. iterative approach

    9. iterative computation

    10. key/value pair

    11. network bandwidth

    12. partitioning function

    13. re-execute

    14. restart

    15. slaves

  4. Master data structures

  5. Master-slave model

  6. Matrix multiplication

  7. Model-view-controller programming style

  8. Monads

  9. MongoDB

  10. Monitor lock

  11. Mutable arrays

  12. Mutable variables (MVars)

    1. putMVar

    2. skip channel

    3. STM

    4. takeMVar

    5. working

N

  1. Network bandwidth

  2. Network.Socket library

  3. Non-strict strategies

SeeLazy evaluation

O

  1. Object-oriented programming (OOP) vs . FP

  2. OpenRefine tool

P

  1. PageRank algorithm

  2. Parallel arrays

    1. dot product

    2. vs. lists

  3. Parallelism

    1. dataflow diagram

    2. definition

    3. Eval monad

    4. Fibonacci numbers

    5. IVar

    6. MVar

    7. parMapM

    8. Par monad

    9. pseq

    10. spawn function

  4. Parallel programming model

  5. Parametric polymorphism

  6. Partial application

  7. Pattern matching

  8. Petabyte

  9. Polymorphic implementation

  10. Polymorphic value

  11. Prefix notation

  12. Printf debugging

Q

  1. QuickCheck test

R

  1. RapidMiner device

  2. Reactor pattern

  3. Recursion

  4. Reducible expression (redex)

  5. Relational database management systems (RDBMS)

  6. return function

  7. Run-time type inference

    1. constraint

    2. debugger

    3. efficiency

    4. new types

    5. phases

    6. reconstruction

    7. termination

S

  1. Safe library

  2. Scan family

    1. NFData

    2. parList

    3. rdeepseq

  3. Scheduler pattern

  4. Secondary effect

  5. Semantic error

  6. Serialization

  7. Server-based applications

  8. Shared-memory multiprocessor (SMP)

  9. Side effects

  10. simplelocalnet topology

  11. Simple value

  12. Sloan Digital Sky Survey (SDSS)

  13. Socket server

  14. Software transactional memory (STM)

    1. atomically function

    2. atomic blocks

    3. atomicity

    4. bank account

    5. buffer

    6. GHC

    7. good scalability

    8. isolation

    9. launchMissiles

    10. limitedWithdraw

    11. low sequential overhead

    12. optimistic execution

    13. orElse

    14. re-execution

    15. resource allocation

    16. retry function

    17. strong progress guarantees

    18. unlimited buffer

  15. Source code files

  16. Source-located errors

  17. Space profiling

    1. file names

    2. QuickCheck

    3. README

    4. results

    5. split function

  18. Spark pool

  19. Synchronized methods

  20. Synchronous event demultiplexer

  21. Synchronous exceptions

  22. Syntax error

  23. System.IO for sockets

T

  1. takeWhile function

  2. Talend

  3. Thread pool pattern

  4. Threads for parallel programming

    1. cancellation

    2. dupChan function

    3. fix permits

    4. forkIO

    5. hash

    6. liftM permits

    7. MVars

    8. printNrResults

    9. runconnection

    10. server-based applications

    11. stdout

    12. web applications

  5. throw function

  6. Tick technique

  7. timeout variants

  8. Time profiling

  9. Time-space correlated

  10. Transactional memory

    1. atomicity

    2. concurrency

    3. launchMissiles

    4. read logs

    5. re-execution

  11. Trapeze method

  12. Tuples

  13. Typed channels

  14. Type inference

U

  1. User Datagram Protocol (UDP)

V

  1. Vectorization

  2. Virtual memory

W

  1. Weak head normal form (WHNF)

  2. Web applications

  3. WinGHCi window

  4. wxHaskell

X, Y

  1. xmonad

Z

  1. ZeroMQ library

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.118.163.159