*** Key Features ***
* Apply the Clojure programming language in financial analytics and to build financial applications
* Work with high-level mathematical abstractions without having to implement low-level code for financial operations.
* This is a practical tutorial that takes you through real-world more » examples of financial analytics and applications with Clojure
*** Book Description ***
Clojure is a dynamic programming language with an emphasis on functional programming. Clojure is well suited to financial modeling as it is a functional programming language. Such languages help developers work with high-level mathematical abstractions without having to implement low-level code that handles the arithmetic operations.
Starting with the importance of representing data and calculations effectively, this book will take you all the way to being competent in financial analytics and building financial applications.
First, we introduce the notions of computation and finance, which will help you understand Clojure's utility to solve real-world problems in many domains, especially finance. Next, we will show you how to develop the simple-moving-average function by using the more advanced partition Clojure data transformation function. This function, along with others, will be used to calculate and manipulate data.
You will then learn to implement slightly more complicated equations, how to traverse data, and deal with branching and conditional dispatch. Then, the concept of side-effecting and its various approaches are introduced, along with the strategy of how to use data as the interface to other systems. Finally, you will discover how to build algorithms while manipulating and composing functions.
*** What you will learn ***
* Quickly and effectively represent data and calculations using Clojure
* Use Clojure's basic language tools such as laziness, immutability, and firstclass functions to solve real-world problems
* Explore mathematical derivatives to generate different wave forms
* Get acquainted with the advanced approaches to calculating and transforming data, and building algorithms
* Use Clojure's functions to access, update, and compose data structures
* Be introduced to the concept of sideeffecting behavior and the different ways to handle it
* Compose simple and exponential functions together to get a buy or sell signal
*** About the Author ***
Timothy Washington is a senior software developer with over 15 years of experience in designing and building enterprise web applications from end to end. His experience includes delivering stable, robust software architectures to organizations ranging from start-ups to Fortune 500 companies. His skills include managing agile projects, systems analysis and design, functional programming, DSL and language design, and object-oriented design, with contributions to the open source community.
*** Table of Contents ***
1. Orientation – Addressing the Questions Clojure Answers
2. First Principles and a Useful Way to Think
3. Developing the Simple Moving Average
4. Strategies for Calculating and Manipulating Data
5. Traversing Data, Branching, and Conditional Dispatch
6. Surveying the Landscape
7. Dealing with Side Effects
8. Strategies for Using Macros
9. Building Algorithms – Strategies to Manipulate and Compose Functions « less
A fully revised edition that covers the new features available in Clojure 1.6.
About the Technology
Clojure is a modern Lisp for the JVM. It has the strengths you expect: first-class functions, macros, and Lisp's clean programming style. It supports functional programming, making it more » ideal for concurrent programming and for creating domain-specific languages. Clojure lets you solve harder problems, make faster changes, and end up with a smaller code base. It's no wonder that there are so many Clojure success stories.
About the Book
Clojure in Action, Second Edition is an expanded and improved version that's been updated to cover the new features of Clojure 1.6. The book gives you a rapid introduction to the Clojure language, moving from abstract theory to practical examples. You'll start by learning how to use Clojure as a general-purpose language. Next, you'll explore Clojure's efficient concurrency model, based on the database concept of Software Transactional Memory (STM). You'll gain a new level of productivity through Clojure DSLs that can run on the JVM. Along the way, you'll learn countless tips, tricks, and techniques for writing smaller, safer, and faster code.
* Functional programming basics
* Metaprogramming with Clojure's macros
* Interoperating with Java
* Covers Clojure 1.6
About the Reader
Assumes readers are familiar with a programming language like C, Java, Ruby, or Python.
About the Author
Amit Rathore has 12 years of experience building large-scale, data-heavy applications for a variety of domains. Francis Avila is a software developer at Breeze with seven years of experience in back- and front-end web development.
Table of Contents
1. Introducing Clojure
2. Clojure elements: Data structures and functions
3. Building blocks of Clojure
4. Multimethod polymorphism
5. Exploring Clojure and Java interop
6. State and the concurrent world
7. Evolving Clojure through macros
8. More on functional programming
9. Protocols, records, and types
10. Test-driven development and more
11. More macros and DSL « less
Master the art of agile single page web application development with ClojureScript
About This Book
Build Bulletproof Web Apps with Less Code
Modern web applications deserve modern tools. Harness the JVM's rich infrastructure while taking advantage of the expressive power and brisk performance of a modern functional language. Exploit Clojure's unique advantages for web development. Step by step, apply the fundamentals of programming in Clojure more » to build real-world, professional web applications. This edition features new libraries, tools, and best practices, and focuses on developing modern single-page applications.
Stop developing web apps with yesterday's tools. Today, developers are increasingly adopting Clojure as a web-development platform. See for yourself what makes Clojure so desirable, as you create a series of web apps of growing complexity, exhibiting the full process of web development using a modern functional language. Journey through all the steps in developing a rich Picture Gallery web application--from conception to packaging and deployment. You'll work hands-on with Clojure and build real-world, professional web apps.
This fully updated second edition reveals the changes in the rapidly evolving Clojure ecosystem. Get up to speed on the many new libraries, tools, and best practices. Gain expertise in the popular Ring/Compojure stack using the Luminus framework. Learn how Clojure works with databases and speeds development of RESTful services. See why ClojureScript is rapidly becoming a popular front-end platform, and use ClojureScript with the popular Reagent library to build single-page applications.
This book is for you, whether you're already familiar with Clojure or if you're completely new to the language.
What You Need:
The latest JVM, Clojure 1.6+, and the Leiningen build tool, as well as an editor such as Emacs, IntelliJ, Eclipse, Light Table, or VI. « less
From Practice to Practitioner
Think in the Clojure way! Once you're familiar with Clojure, take the next step with extended lessons on the best practices and most critical decisions you'll need to make while developing. Learn how to model your domain with data, transform it with pure functions, manage state, spread your work across more » cores, and structure apps with components. Discover how to use Clojure in the real world, and unlock the speed and power of this beautiful language on the Java Virtual Machine.
Clojure Applied gives you the practical, realistic advice and depth of field that's been missing from your development practice. You want to develop software in the most effective, efficient way possible. This book gives you the answers you've been looking for in friendly, clear language.
Dive into the core concepts of Clojure: immutable collections, concurrency, pure functions, and state management. You'll finally get the complete picture you've been looking for, rather than dozens of puzzle pieces you must assemble yourself. First, explore the core concepts of Clojure development: learn how to model your domain with immutable data; choose the ideal collection; and write simple, pure functions for efficient transformation. Next you'll apply those core concepts to build applications: discover how Clojure manages state and identity; spread your work for concurrent programming; and create and assemble components. Finally, see how to manage external integration and deployment concerns by developing a testing strategy, connecting with other data sources, and getting your libraries and applications out the door.
Go beyond the toy box and into Clojure's way of thinking. By the end of this book, you'll have the tools and information to put Clojure's strengths to work.
What You Need:
To follow along with the examples in the book, you will need Clojure 1.6, Leinegen 2, and Java 6 or higher. « less
Dive into data analysis with Clojure through over 100 practical recipes for every stage of the analysis and collection process
This book is for those with a basic knowledge of Clojure, who are looking to push the language to excel with data analysis.
25 recipes to deeply understand and implement advanced algorithms in Clojure
***** About 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 more » approaches such as logic or asynchronous programming
***** Who This Book Is For *****
This book is for intermediate Clojure developers who can read and write in this language quite comfortably. Besides, it is assumed that you have some knowledge of how to set up Clojure projects, include dependencies, how to run REPLs, and so on through Leiningen and Figwheel. No prior awareness of any of the algorithms covered in this book is needed, and, when appropriate, pointers are given to the explanation material about any theory related to them.
***** What You Will Learn *****
* Explore alternative uses of classical data structures such as arrays and linked lists
* Explore advanced machine learning and optimization techniques
* Utilize the 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 core.logic library
* Master asynchronous programming using the core.async library
* Observe transducers while resolving real-world use cases
***** In Detail *****
Clojure is a highly pragmatic language with efficient and easy data manipulation capabilities. This provides us with an opportunity to easily explore many challenging and varied algorithmic topics, while using some extremely creative methods.
In this book, we'll discover alternative uses for classical data structures (arrays, linked lists, and trees), cover some machine learning and optimization techniques, and even delve into some innovative ways of approaching algorithmic problem solving, such as logic programming, asynchronous programming or the usage of advanced functional constructs, namely transducers or the continuation passing style. « less
Statistics, big data, and machine learning for Clojure programmers
***** About This Book *****
* Write code using Clojure to harness the power of your data
* Discover the libraries and frameworks that will help you succeed
* A practical guide to understanding how the Clojure programming language can be used to derive insights from data
***** Who This Book Is more » For *****
This book is aimed at developers who are already productive in Clojure but who are overwhelmed by the breadth and depth of understanding required to be effective in the field of data science. Whether you're tasked with delivering a specific analytics project or simply suspect that you could be deriving more value from your data, this book will inspire you with the opportunities–and inform you of the risks–that exist in data of all shapes and sizes.
***** What You Will Learn *****
* Perform hypothesis testing and understand feature selection and statistical significance to interpret your results with confidence
* Implement the core machine learning techniques of regression, classification, clustering and recommendation
* Understand the importance of the value of simple statistics and distributions in exploratory data analysis
* Scale algorithms to web-sized datasets efficiently using distributed programming models on Hadoop and Spark
* Apply suitable analytic approaches for text, graph, and time series data
* Interpret the terminology that you will encounter in technical papers
* Import libraries from other JVM languages such as Java and Scala
* Communicate your findings clearly and convincingly to nontechnical colleagues
***** In Detail *****
The term “data science” has been widely used to define this new profession that is expected to interpret vast datasets and translate them to improved decision-making and performance. Clojure is a powerful language that combines the interactivity of a scripting language with the speed of a compiled language. Together with its rich ecosystem of native libraries and an extremely simple and consistent functional approach to data manipulation, which maps closely to mathematical formula, it is an ideal, practical, and flexible language to meet a data scientist's diverse needs.
Taking you on a journey from simple summary statistics to sophisticated machine learning algorithms, this book shows how the Clojure programming language can be used to derive insights from data. Data scientists often forge a novel path, and you'll see how to make use of Clojure's Java interoperability capabilities to access libraries such as Mahout and Mllib for which Clojure wrappers don't yet exist. Even seasoned Clojure developers will develop a deeper appreciation for their language's flexibility!
You'll learn how to apply statistical thinking to your own data and use Clojure to explore, analyze, and visualize it in a technically and statistically robust way. You can also use Incanter for local data processing and ClojureScript to present interactive visualisations and understand how distributed platforms such as Hadoop sand Spark's MapReduce and GraphX's BSP solve the challenges of data analysis at scale, and how to explain algorithms using those programming models.
Above all, by following the explanations in this book, you'll learn not just how to be effective using the current state-of-the-art methods in data science, but why such methods work so that you can continue to be productive as the field evolves into the future.
***** Style and approach *****
This is a practical guide to data science that teaches theory by example through the libraries and frameworks accessible from the Clojure programming language. « less
Become an expert at writing fast and high performant code in Clojure 1.7.0
ABOUT THIS BOOK
* Enhance code performance by using appropriate Clojure features
* Improve the efficiency of applications and plan their deployment
* A hands-on guide to designing Clojure programs to get the best performance
WHO THIS BOOK IS FOR
This book is intended for intermediate Clojure developers more » who are looking to get a good grip on achieving optimum performance. Having a basic knowledge of Java would be helpful.
WHAT YOU WILL LEARN
* Identify performance issues in Clojure programs using different profiling tools
* Master techniques to achieve numerical performance in Clojure
* Use Criterium library to measure latency of Clojure expressions
* Exploit Java features in Clojure code to enhance performance
* Avoid reflection and boxing with type hints
* Understand Clojure's concurrency and state-management primitives in depth
* Measure and monitor performance, and understand optimization techniques
Clojure treats code as data and has a macro system. It focuses on programming with immutable values and explicit progression-of-time constructs, which are intended to facilitate the development of more robust programs, particularly multithreaded ones. It is built with performance, pragmatism, and simplicity in mind. Like most general purpose languages, various Clojure features have different performance characteristics that one should know in order to write high performance code.
This book shows you how to evaluate the performance implications of various Clojure abstractions, discover their underpinnings, and apply the right approach for optimum performance in real-world programs.
It starts by helping you classify various use cases and the need for them with respect to performance and analysis of various performance aspects. You will also learn the performance vocabulary that experts use throughout the world and discover various Clojure data structures, abstractions, and their performance characteristics. Further, the book will guide you through enhancing performance by using Java interoperability and JVM-specific features from Clojure. It also highlights the importance of using the right concurrent data structure and Java concurrency abstractions.
This book also sheds light on performance metrics for measuring, how to measure, and how to visualize and monitor the collected data. At the end of the book, you will learn to run a performance profiler, identify bottlenecks, tune performance, and refactor code to get a better performance.
STYLE AND APPROACH
An easy-to-follow guide full of real-world examples and self-sufficient code snippets that will help you get your hands dirty with high performance programming with Clojure. « less
Design and implement highly reusable reactive applications by integrating different frameworks with Clojure
Reactive Programming (RP) is central to many concurrent systems. It endeavors to make the process of developing highly-concurrent, event-driven, and asynchronous applications simpler and less error-prone. RP comes in many flavors and we will look at some of them in this book.
Clojure Reactive Programming more » is a practical guide aimed at exploring RP. It starts by describing Functional Reactive Programming (FRP) and its formulations, as well as how it inspired Compositional Event Systems (CES).
It also presents several examples of Reactive applications implemented in different frameworks, allowing you to develop an understanding of the subject as well as learn how to develop your ability to work with time-varying values.
By the end of the book, you will be equipped to solve real-world problems as well as understand the trade-offs between the approaches shown in the book.
***** Who This Book Is For *****
If you are a Clojure developer who is interested in using Reactive Programming to build asynchronous and concurrent applications, this book is for you. Knowledge of Clojure and Leiningen is required. Basic understanding of ClojureScript will be helpful for the web chapters, although it is not strictly necessary. « less