Clojure data structures and algorithms cookbook: 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure
Saved in:
| Main Author: | |
|---|---|
| Format: | Electronic eBook |
| Language: | English |
| Published: |
Birmingham, UK
Packt Publishing
2015
|
| Series: | Quick answers to common problems
|
| Subjects: | |
| Item Description: | Online resource; title from cover (Safari, viewed September 4, 2015). - Includes index |
| Physical Description: | 1 online resource (1 volume) illustrations |
| ISBN: | 9781785287824 1785287826 |
Staff View
MARC
| LEADER | 00000nmm a2200000zc 4500 | ||
|---|---|---|---|
| 001 | BV045351315 | ||
| 003 | DE-604 | ||
| 005 | 00000000000000.0 | ||
| 007 | cr|uuu---uuuuu | ||
| 008 | 181210s2015 |||| o||u| ||||||eng d | ||
| 020 | |a 9781785287824 |9 978-1-78528-782-4 | ||
| 020 | |a 1785287826 |9 1-78528-782-6 | ||
| 035 | |a (ZDB-4-ITC)ocn920970925 | ||
| 035 | |a (OCoLC)920970925 | ||
| 035 | |a (DE-599)BVBBV045351315 | ||
| 040 | |a DE-604 |b ger |e rda | ||
| 041 | 0 | |a eng | |
| 082 | 0 | |a 005.133 |2 23 | |
| 100 | 1 | |a Naccache, Rafik |e Verfasser |4 aut | |
| 245 | 1 | 0 | |a Clojure data structures and algorithms cookbook |b 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure |c Rafik Naccache |
| 246 | 1 | 3 | |a 25 recipes to deeply understand and implement advanced algorithms in Clojure |
| 246 | 1 | 3 | |a Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure |
| 246 | 1 | 1 | |a Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure |
| 264 | 1 | |a Birmingham, UK |b Packt Publishing |c 2015 | |
| 300 | |a 1 online resource (1 volume) |b illustrations | ||
| 336 | |b txt |2 rdacontent | ||
| 337 | |b c |2 rdamedia | ||
| 338 | |b cr |2 rdacarrier | ||
| 490 | 0 | |a Quick answers to common problems | |
| 500 | |a Online resource; title from cover (Safari, viewed September 4, 2015). - Includes index | ||
| 505 | 8 | |a 25 recipes to deeply understand and implement advanced algorithms in ClojureAbout This Book Explore various advanced algorithms and learn how they are used to address many real-world computing challenges Construct elegant solutions using impressive techniques including zippers, parsing, and pattern matching Solve complex problems by adopting innovative approaches such as logic or asynchronous programmingIn Detail Data-structures and algorithms often cross your path when you compress files, compile programs, access databases, or simply use your favourite text editor. Understanding and implementing them can be daunting. Curious learners and industrial developers can find these complex, especially if they focus on the detailed implementation of these data structures. Clojure is a highly pragmatic and expressive language with efficient and easy data manipulation capabilities. As such, it is great for implementing these algorithms. | |
| 505 | 8 | |a By abstracting away a great share of the unnecessary complexity resulting from implementation, Clojure and its contrib libraries will help you address various algorithmic challenges, making your data exploration both profitable and enjoyable. Through 25 recipes, you'll explore advanced algorithms and data-structures, well served by a sound Clojure implementation. This book opens with an exploration of alternative uses of the array data-structure, covering LZ77 compression, drawing fractals using Pascal's triangles, simulating a multi-threaded program execution, and implementing a call-stack winding and un-winding operations. The book elaborates on linked lists, showing you how to construct doubly linked ones, speed up search times over the elements of such structures, use a linked-list as the foundation of a shift-reduce parser, and implement an immutable linked-list using skew binary numbers representation. | |
| 505 | 8 | |a After that, the tree data-structure is explored, focusing on building self-balancing Splay Trees, designing a B-Tree backing-up an efficient key-value data-store, constructing an undo capable Rope, and showing how Tries can make for an auto-completing facility. Next, some optimization and machine learning techniques are discussed, namely for building a co-occurrence-based recommendation engine, using branch-and-bound to optimize integral cost and profit problems, using Dijkstra's algorithm to determine optimal paths and summarizing texts using the LexRank algorithm. Particular attention is given to logic programming, you will learn to use this to discover interesting relations between social website data, by designing a simple type inferencer for a mini Java-like language, and by building a simple checkers game engine. Asynchronous programming will be addressed and you will design a concurrent web-crawler, an interactive HTML5 game, and an online taxi booking platform. | |
| 505 | 8 | |a Finally, you'll explore advanced cases for higher order functions in Clojure while implementing a recursive descent parser using efficient mutual resucrsion, devising a mini resusable firewall simulator thanks to Clojure 1.7 new tansducers feature or building a simple unification engine with the help of Continuation Passing Style. | |
| 505 | 8 | |a What You Will Learn Explore alternative uses of classical data-structures like arrays and linked-lists Discover advanced types of tree data-structures Explore advanced machine learning and optimization techniques Utilise powerful Clojure libraries, such as Instaparse for parsing, core.match for pattern matching, clojure.zip for zippers, and clojure.matrix for matrix operations Learn logic programming through the usage of the library core.logic Master asynchronous programming using the core.async library See the transducers in action while resolving real-world use-casesWho This Book Is For If you are an experienced Clojure developer, longing to take your knowledge to the next level by discovering and using advanced algorithms and seeing how they can be applied to real-world problems, then this book is for you. Style and approach This book consists of a set of step-by-step recipes, each demonstrating the material covered in action so it is put in context. | |
| 505 | 8 | |a When necessary, pointers to further resources are provided | |
| 650 | 7 | |a COMPUTERS / Programming Languages / General |2 bisacsh | |
| 650 | 7 | |a Clojure (Computer program language) |2 fast | |
| 650 | 7 | |a Functional programming languages |2 fast | |
| 650 | 4 | |a Clojure (Computer program language) |a Functional programming languages | |
| 776 | 0 | 8 | |i Erscheint auch als |n Druck-Ausgabe |t Naccache, Rafik. Clojure Data Structures and Algorithms Cookbook |
| 912 | |a ZDB-4-ITC | ||
| 999 | |a oai:aleph.bib-bvb.de:BVB01-030737968 | ||
Record in the Search Index
| _version_ | 1804179176660402176 |
|---|---|
| any_adam_object | |
| author | Naccache, Rafik |
| author_facet | Naccache, Rafik |
| author_role | aut |
| author_sort | Naccache, Rafik |
| author_variant | r n rn |
| building | Verbundindex |
| bvnumber | BV045351315 |
| collection | ZDB-4-ITC |
| contents | 25 recipes to deeply understand and implement advanced algorithms in ClojureAbout This Book Explore various advanced algorithms and learn how they are used to address many real-world computing challenges Construct elegant solutions using impressive techniques including zippers, parsing, and pattern matching Solve complex problems by adopting innovative approaches such as logic or asynchronous programmingIn Detail Data-structures and algorithms often cross your path when you compress files, compile programs, access databases, or simply use your favourite text editor. Understanding and implementing them can be daunting. Curious learners and industrial developers can find these complex, especially if they focus on the detailed implementation of these data structures. Clojure is a highly pragmatic and expressive language with efficient and easy data manipulation capabilities. As such, it is great for implementing these algorithms. By abstracting away a great share of the unnecessary complexity resulting from implementation, Clojure and its contrib libraries will help you address various algorithmic challenges, making your data exploration both profitable and enjoyable. Through 25 recipes, you'll explore advanced algorithms and data-structures, well served by a sound Clojure implementation. This book opens with an exploration of alternative uses of the array data-structure, covering LZ77 compression, drawing fractals using Pascal's triangles, simulating a multi-threaded program execution, and implementing a call-stack winding and un-winding operations. The book elaborates on linked lists, showing you how to construct doubly linked ones, speed up search times over the elements of such structures, use a linked-list as the foundation of a shift-reduce parser, and implement an immutable linked-list using skew binary numbers representation. After that, the tree data-structure is explored, focusing on building self-balancing Splay Trees, designing a B-Tree backing-up an efficient key-value data-store, constructing an undo capable Rope, and showing how Tries can make for an auto-completing facility. Next, some optimization and machine learning techniques are discussed, namely for building a co-occurrence-based recommendation engine, using branch-and-bound to optimize integral cost and profit problems, using Dijkstra's algorithm to determine optimal paths and summarizing texts using the LexRank algorithm. Particular attention is given to logic programming, you will learn to use this to discover interesting relations between social website data, by designing a simple type inferencer for a mini Java-like language, and by building a simple checkers game engine. Asynchronous programming will be addressed and you will design a concurrent web-crawler, an interactive HTML5 game, and an online taxi booking platform. Finally, you'll explore advanced cases for higher order functions in Clojure while implementing a recursive descent parser using efficient mutual resucrsion, devising a mini resusable firewall simulator thanks to Clojure 1.7 new tansducers feature or building a simple unification engine with the help of Continuation Passing Style. What You Will Learn Explore alternative uses of classical data-structures like arrays and linked-lists Discover advanced types of tree data-structures Explore advanced machine learning and optimization techniques Utilise powerful Clojure libraries, such as Instaparse for parsing, core.match for pattern matching, clojure.zip for zippers, and clojure.matrix for matrix operations Learn logic programming through the usage of the library core.logic Master asynchronous programming using the core.async library See the transducers in action while resolving real-world use-casesWho This Book Is For If you are an experienced Clojure developer, longing to take your knowledge to the next level by discovering and using advanced algorithms and seeing how they can be applied to real-world problems, then this book is for you. Style and approach This book consists of a set of step-by-step recipes, each demonstrating the material covered in action so it is put in context. When necessary, pointers to further resources are provided |
| ctrlnum | (ZDB-4-ITC)ocn920970925 (OCoLC)920970925 (DE-599)BVBBV045351315 |
| dewey-full | 005.133 |
| dewey-hundreds | 000 - Computer science, information, general works |
| dewey-ones | 005 - Computer programming, programs, data, security |
| dewey-raw | 005.133 |
| dewey-search | 005.133 |
| dewey-sort | 15.133 |
| dewey-tens | 000 - Computer science, information, general works |
| discipline | Informatik |
| format | Electronic eBook |
| fullrecord | <?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>06182nmm a2200481zc 4500</leader><controlfield tag="001">BV045351315</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">00000000000000.0</controlfield><controlfield tag="007">cr|uuu---uuuuu</controlfield><controlfield tag="008">181210s2015 |||| o||u| ||||||eng d</controlfield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9781785287824</subfield><subfield code="9">978-1-78528-782-4</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">1785287826</subfield><subfield code="9">1-78528-782-6</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(ZDB-4-ITC)ocn920970925</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)920970925</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)BVBBV045351315</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">eng</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">005.133</subfield><subfield code="2">23</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Naccache, Rafik</subfield><subfield code="e">Verfasser</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Clojure data structures and algorithms cookbook</subfield><subfield code="b">25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure</subfield><subfield code="c">Rafik Naccache</subfield></datafield><datafield tag="246" ind1="1" ind2="3"><subfield code="a">25 recipes to deeply understand and implement advanced algorithms in Clojure</subfield></datafield><datafield tag="246" ind1="1" ind2="3"><subfield code="a">Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure</subfield></datafield><datafield tag="246" ind1="1" ind2="1"><subfield code="a">Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Birmingham, UK</subfield><subfield code="b">Packt Publishing</subfield><subfield code="c">2015</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">1 online resource (1 volume)</subfield><subfield code="b">illustrations</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">c</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">cr</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="490" ind1="0" ind2=" "><subfield code="a">Quick answers to common problems</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Online resource; title from cover (Safari, viewed September 4, 2015). - Includes index</subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">25 recipes to deeply understand and implement advanced algorithms in ClojureAbout This Book Explore various advanced algorithms and learn how they are used to address many real-world computing challenges Construct elegant solutions using impressive techniques including zippers, parsing, and pattern matching Solve complex problems by adopting innovative approaches such as logic or asynchronous programmingIn Detail Data-structures and algorithms often cross your path when you compress files, compile programs, access databases, or simply use your favourite text editor. Understanding and implementing them can be daunting. Curious learners and industrial developers can find these complex, especially if they focus on the detailed implementation of these data structures. Clojure is a highly pragmatic and expressive language with efficient and easy data manipulation capabilities. As such, it is great for implementing these algorithms. </subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">By abstracting away a great share of the unnecessary complexity resulting from implementation, Clojure and its contrib libraries will help you address various algorithmic challenges, making your data exploration both profitable and enjoyable. Through 25 recipes, you'll explore advanced algorithms and data-structures, well served by a sound Clojure implementation. This book opens with an exploration of alternative uses of the array data-structure, covering LZ77 compression, drawing fractals using Pascal's triangles, simulating a multi-threaded program execution, and implementing a call-stack winding and un-winding operations. The book elaborates on linked lists, showing you how to construct doubly linked ones, speed up search times over the elements of such structures, use a linked-list as the foundation of a shift-reduce parser, and implement an immutable linked-list using skew binary numbers representation. </subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">After that, the tree data-structure is explored, focusing on building self-balancing Splay Trees, designing a B-Tree backing-up an efficient key-value data-store, constructing an undo capable Rope, and showing how Tries can make for an auto-completing facility. Next, some optimization and machine learning techniques are discussed, namely for building a co-occurrence-based recommendation engine, using branch-and-bound to optimize integral cost and profit problems, using Dijkstra's algorithm to determine optimal paths and summarizing texts using the LexRank algorithm. Particular attention is given to logic programming, you will learn to use this to discover interesting relations between social website data, by designing a simple type inferencer for a mini Java-like language, and by building a simple checkers game engine. Asynchronous programming will be addressed and you will design a concurrent web-crawler, an interactive HTML5 game, and an online taxi booking platform. </subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">Finally, you'll explore advanced cases for higher order functions in Clojure while implementing a recursive descent parser using efficient mutual resucrsion, devising a mini resusable firewall simulator thanks to Clojure 1.7 new tansducers feature or building a simple unification engine with the help of Continuation Passing Style. </subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">What You Will Learn Explore alternative uses of classical data-structures like arrays and linked-lists Discover advanced types of tree data-structures Explore advanced machine learning and optimization techniques Utilise powerful Clojure libraries, such as Instaparse for parsing, core.match for pattern matching, clojure.zip for zippers, and clojure.matrix for matrix operations Learn logic programming through the usage of the library core.logic Master asynchronous programming using the core.async library See the transducers in action while resolving real-world use-casesWho This Book Is For If you are an experienced Clojure developer, longing to take your knowledge to the next level by discovering and using advanced algorithms and seeing how they can be applied to real-world problems, then this book is for you. Style and approach This book consists of a set of step-by-step recipes, each demonstrating the material covered in action so it is put in context. </subfield></datafield><datafield tag="505" ind1="8" ind2=" "><subfield code="a">When necessary, pointers to further resources are provided</subfield></datafield><datafield tag="650" ind1=" " ind2="7"><subfield code="a">COMPUTERS / Programming Languages / General</subfield><subfield code="2">bisacsh</subfield></datafield><datafield tag="650" ind1=" " ind2="7"><subfield code="a">Clojure (Computer program language)</subfield><subfield code="2">fast</subfield></datafield><datafield tag="650" ind1=" " ind2="7"><subfield code="a">Functional programming languages</subfield><subfield code="2">fast</subfield></datafield><datafield tag="650" ind1=" " ind2="4"><subfield code="a">Clojure (Computer program language)</subfield><subfield code="a">Functional programming languages</subfield></datafield><datafield tag="776" ind1="0" ind2="8"><subfield code="i">Erscheint auch als</subfield><subfield code="n">Druck-Ausgabe</subfield><subfield code="t">Naccache, Rafik. Clojure Data Structures and Algorithms Cookbook</subfield></datafield><datafield tag="912" ind1=" " ind2=" "><subfield code="a">ZDB-4-ITC</subfield></datafield><datafield tag="999" ind1=" " ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-030737968</subfield></datafield></record></collection> |
| id | DE-604.BV045351315 |
| illustrated | Illustrated |
| indexdate | 2024-07-10T08:15:42Z |
| institution | BVB |
| isbn | 9781785287824 1785287826 |
| language | English |
| oai_aleph_id | oai:aleph.bib-bvb.de:BVB01-030737968 |
| oclc_num | 920970925 |
| open_access_boolean | |
| physical | 1 online resource (1 volume) illustrations |
| psigel | ZDB-4-ITC |
| publishDate | 2015 |
| publishDateSearch | 2015 |
| publishDateSort | 2015 |
| publisher | Packt Publishing |
| record_format | marc |
| series2 | Quick answers to common problems |
| spelling | Naccache, Rafik Verfasser aut Clojure data structures and algorithms cookbook 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure Rafik Naccache 25 recipes to deeply understand and implement advanced algorithms in Clojure Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure Birmingham, UK Packt Publishing 2015 1 online resource (1 volume) illustrations txt rdacontent c rdamedia cr rdacarrier Quick answers to common problems Online resource; title from cover (Safari, viewed September 4, 2015). - Includes index 25 recipes to deeply understand and implement advanced algorithms in ClojureAbout This Book Explore various advanced algorithms and learn how they are used to address many real-world computing challenges Construct elegant solutions using impressive techniques including zippers, parsing, and pattern matching Solve complex problems by adopting innovative approaches such as logic or asynchronous programmingIn Detail Data-structures and algorithms often cross your path when you compress files, compile programs, access databases, or simply use your favourite text editor. Understanding and implementing them can be daunting. Curious learners and industrial developers can find these complex, especially if they focus on the detailed implementation of these data structures. Clojure is a highly pragmatic and expressive language with efficient and easy data manipulation capabilities. As such, it is great for implementing these algorithms. By abstracting away a great share of the unnecessary complexity resulting from implementation, Clojure and its contrib libraries will help you address various algorithmic challenges, making your data exploration both profitable and enjoyable. Through 25 recipes, you'll explore advanced algorithms and data-structures, well served by a sound Clojure implementation. This book opens with an exploration of alternative uses of the array data-structure, covering LZ77 compression, drawing fractals using Pascal's triangles, simulating a multi-threaded program execution, and implementing a call-stack winding and un-winding operations. The book elaborates on linked lists, showing you how to construct doubly linked ones, speed up search times over the elements of such structures, use a linked-list as the foundation of a shift-reduce parser, and implement an immutable linked-list using skew binary numbers representation. After that, the tree data-structure is explored, focusing on building self-balancing Splay Trees, designing a B-Tree backing-up an efficient key-value data-store, constructing an undo capable Rope, and showing how Tries can make for an auto-completing facility. Next, some optimization and machine learning techniques are discussed, namely for building a co-occurrence-based recommendation engine, using branch-and-bound to optimize integral cost and profit problems, using Dijkstra's algorithm to determine optimal paths and summarizing texts using the LexRank algorithm. Particular attention is given to logic programming, you will learn to use this to discover interesting relations between social website data, by designing a simple type inferencer for a mini Java-like language, and by building a simple checkers game engine. Asynchronous programming will be addressed and you will design a concurrent web-crawler, an interactive HTML5 game, and an online taxi booking platform. Finally, you'll explore advanced cases for higher order functions in Clojure while implementing a recursive descent parser using efficient mutual resucrsion, devising a mini resusable firewall simulator thanks to Clojure 1.7 new tansducers feature or building a simple unification engine with the help of Continuation Passing Style. What You Will Learn Explore alternative uses of classical data-structures like arrays and linked-lists Discover advanced types of tree data-structures Explore advanced machine learning and optimization techniques Utilise powerful Clojure libraries, such as Instaparse for parsing, core.match for pattern matching, clojure.zip for zippers, and clojure.matrix for matrix operations Learn logic programming through the usage of the library core.logic Master asynchronous programming using the core.async library See the transducers in action while resolving real-world use-casesWho This Book Is For If you are an experienced Clojure developer, longing to take your knowledge to the next level by discovering and using advanced algorithms and seeing how they can be applied to real-world problems, then this book is for you. Style and approach This book consists of a set of step-by-step recipes, each demonstrating the material covered in action so it is put in context. When necessary, pointers to further resources are provided COMPUTERS / Programming Languages / General bisacsh Clojure (Computer program language) fast Functional programming languages fast Clojure (Computer program language) Functional programming languages Erscheint auch als Druck-Ausgabe Naccache, Rafik. Clojure Data Structures and Algorithms Cookbook |
| spellingShingle | Naccache, Rafik Clojure data structures and algorithms cookbook 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure 25 recipes to deeply understand and implement advanced algorithms in ClojureAbout This Book Explore various advanced algorithms and learn how they are used to address many real-world computing challenges Construct elegant solutions using impressive techniques including zippers, parsing, and pattern matching Solve complex problems by adopting innovative approaches such as logic or asynchronous programmingIn Detail Data-structures and algorithms often cross your path when you compress files, compile programs, access databases, or simply use your favourite text editor. Understanding and implementing them can be daunting. Curious learners and industrial developers can find these complex, especially if they focus on the detailed implementation of these data structures. Clojure is a highly pragmatic and expressive language with efficient and easy data manipulation capabilities. As such, it is great for implementing these algorithms. By abstracting away a great share of the unnecessary complexity resulting from implementation, Clojure and its contrib libraries will help you address various algorithmic challenges, making your data exploration both profitable and enjoyable. Through 25 recipes, you'll explore advanced algorithms and data-structures, well served by a sound Clojure implementation. This book opens with an exploration of alternative uses of the array data-structure, covering LZ77 compression, drawing fractals using Pascal's triangles, simulating a multi-threaded program execution, and implementing a call-stack winding and un-winding operations. The book elaborates on linked lists, showing you how to construct doubly linked ones, speed up search times over the elements of such structures, use a linked-list as the foundation of a shift-reduce parser, and implement an immutable linked-list using skew binary numbers representation. After that, the tree data-structure is explored, focusing on building self-balancing Splay Trees, designing a B-Tree backing-up an efficient key-value data-store, constructing an undo capable Rope, and showing how Tries can make for an auto-completing facility. Next, some optimization and machine learning techniques are discussed, namely for building a co-occurrence-based recommendation engine, using branch-and-bound to optimize integral cost and profit problems, using Dijkstra's algorithm to determine optimal paths and summarizing texts using the LexRank algorithm. Particular attention is given to logic programming, you will learn to use this to discover interesting relations between social website data, by designing a simple type inferencer for a mini Java-like language, and by building a simple checkers game engine. Asynchronous programming will be addressed and you will design a concurrent web-crawler, an interactive HTML5 game, and an online taxi booking platform. Finally, you'll explore advanced cases for higher order functions in Clojure while implementing a recursive descent parser using efficient mutual resucrsion, devising a mini resusable firewall simulator thanks to Clojure 1.7 new tansducers feature or building a simple unification engine with the help of Continuation Passing Style. What You Will Learn Explore alternative uses of classical data-structures like arrays and linked-lists Discover advanced types of tree data-structures Explore advanced machine learning and optimization techniques Utilise powerful Clojure libraries, such as Instaparse for parsing, core.match for pattern matching, clojure.zip for zippers, and clojure.matrix for matrix operations Learn logic programming through the usage of the library core.logic Master asynchronous programming using the core.async library See the transducers in action while resolving real-world use-casesWho This Book Is For If you are an experienced Clojure developer, longing to take your knowledge to the next level by discovering and using advanced algorithms and seeing how they can be applied to real-world problems, then this book is for you. Style and approach This book consists of a set of step-by-step recipes, each demonstrating the material covered in action so it is put in context. When necessary, pointers to further resources are provided COMPUTERS / Programming Languages / General bisacsh Clojure (Computer program language) fast Functional programming languages fast Clojure (Computer program language) Functional programming languages |
| title | Clojure data structures and algorithms cookbook 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure |
| title_alt | 25 recipes to deeply understand and implement advanced algorithms in Clojure Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure |
| title_auth | Clojure data structures and algorithms cookbook 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure |
| title_exact_search | Clojure data structures and algorithms cookbook 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure |
| title_full | Clojure data structures and algorithms cookbook 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure Rafik Naccache |
| title_fullStr | Clojure data structures and algorithms cookbook 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure Rafik Naccache |
| title_full_unstemmed | Clojure data structures and algorithms cookbook 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure Rafik Naccache |
| title_short | Clojure data structures and algorithms cookbook |
| title_sort | clojure data structures and algorithms cookbook 25 recipes to deeply understand and implement advanced algorithms in clojure twenty five recipes to deeply understand and implement advanced algorithms in clojure |
| title_sub | 25 recipes to deeply understand and implement advanced algorithms in Clojure = Twenty-five recipes to deeply understand and implement advanced algorithms in Clojure |
| topic | COMPUTERS / Programming Languages / General bisacsh Clojure (Computer program language) fast Functional programming languages fast Clojure (Computer program language) Functional programming languages |
| topic_facet | COMPUTERS / Programming Languages / General Clojure (Computer program language) Functional programming languages Clojure (Computer program language) Functional programming languages |
| work_keys_str_mv | AT naccacherafik clojuredatastructuresandalgorithmscookbook25recipestodeeplyunderstandandimplementadvancedalgorithmsinclojuretwentyfiverecipestodeeplyunderstandandimplementadvancedalgorithmsinclojure AT naccacherafik 25recipestodeeplyunderstandandimplementadvancedalgorithmsinclojure AT naccacherafik twentyfiverecipestodeeplyunderstandandimplementadvancedalgorithmsinclojure |