This textbook describes all phases of a compiler: lexical analysis, parsing, abstract syntax, semantic actions, intermediate representations, instruction selection via tree matching, dataflow analysis, graph-coloring register allocation, and runtime systems. It includes good coverage of current techniques in code generation and register allocation, as well as the compilation of functional and object-oriented languages, that is missing from most books. The most accepted and successful techniques are described concisely, rather than as an exhaustive catalog of every possible variant, and illustrated with actual Java classes. The first part of the book, Fundamentals of Compilation, is suitable for a one-semester first course in compiler design. The second part, Advanced Topics, which includes the compilation of object-oriented and functional languages, garbage collection, loop optimization, SSA form, instruction scheduling, and optimization for cache-memory hierarchies, can be used for a second-semester or graduate course. This new edition has been extensively rewritten to include more discussion of Java and object-oriented programming concepts, such as visitor patterns. A unique feature is the newly redesigned compiler project in Java, for a subset of Java itself. The project includes both front-end and back-end phases, so that students can build a complete working compiler in one semester.

Overcome the steep learning curve to start effectively using LLVM libraries and tools
Key Features
Learn how to configure, build, and use LLVM and Clang based tools,
Explore the depths of the LLVM front-end, IR, code generator, and libraries, and learn how a modern compiler is implemented in a practical way,
Customize your project to benefit from Just in Time compilation (JIT), static analysis and source-to-source transformations.
Book Description
This book is intended for enthusiasts, computer developers, and compiler engineers interested in learning about the LLVM framework internals as well as for C++ software engineers keen to use compiler-based tools for code analysis and improvement. You need a background in C++ and, although not mandatory, should know at least some compiler theory. Whether you are a newcomer or a compiler expert, this book provides a practical introduction to LLVM and avoids complex scenarios. If you are interested enough and excited about this technology, then this book is definitely for you.
LLVM is a leading compiler technology framework. Easily extendable and designed as a multitude of libraries, LLVM provides a smooth experience for compiler newcomers and reduces the steep learning curve often associated with compiler development. To start, this book will show you how to configure, build, and install LLVM libraries, tools, and external projects. Next, you will be introduced to LLVM design and how it works in practice throughout each LLVM compiler stage: frontend, optimizer, and backend. The final chapters of this book will address just-in-time compilation issues. Despite initially LLVM was not designed as a JIT-compiler, high demand for dynamic languages pushed the community to implement JIT-compilation features in LLVM. The book will summarize the current state of JIT-compilation support LLVM provides.
By the end of the book, with multiple hands-on examples and source code snippets, you will be able to put a solid and smooth first step into the LLVM compiler development framework.
What you will learn
Understand LLVM compiler high-level design
Extend the compiler frontend, optimizer and backend
Use LLVM as a just-in-time compiler
Understand an architecture description with TableGen
Use compiler-based tools to improve the quality of code in a C++ project
Understand how clang based tools could help even in non-compiler development
Understand LLVM coding style and coding practice
Who This Book Is For
This book is intended for enthusiasts, computer science students, and compiler engineers interested in learning about the LLVM framework. You need a background in C++ and, although not mandatory, should know at least some compiler theory.

Written by leading authorities in database and Web technologies, this book is essential reading for students and practitioners alike. The popularity of the Web and Internet commerce provides many extremely large datasets from which information can be gleaned by data mining. This book focuses on practical algorithms that have been used to solve key problems in data mining and can be applied successfully to even the largest datasets. It begins with a discussion of the map-reduce framework, an important tool for parallelizing algorithms automatically. The authors explain the tricks of locality-sensitive hashing and stream processing algorithms for mining data that arrives too fast for exhaustive processing. Other chapters cover the PageRank idea and related tricks for organizing the Web, the problems of finding frequent itemsets and clustering. This second edition includes new and extended coverage on social networks, machine learning and dimensionality reduction.

A high-performance data access layer must resonate with the underlying database system. Knowing the inner workings of a relational database and the data access frameworks in use can make the difference between a high-performance enterprise application and one that barely crawls.
This book is a journey into Java data access performance tuning. From connection management, to batch updates, fetch sizes and concurrency control mechanisms, it unravels the inner workings of the most common Java data access frameworks.
The first part aims to reduce the gap between application developers and database administrators. For this reason, it covers both JDBC and the database fundamentals that are of paramount importance when reducing transaction response times. In this first part, you'll learn about connection management, batch updates, statement caching, result set fetching and database transactions.
The second part demonstrates how you can take advantage of JPA and Hibernate without compromising application performance. In this second part, you'll learn about the most efficient Hibernate mappings (basic types, associations, inheritance), fetching best practices, caching and concurrency control mechanisms.
The third part is dedicated to jOOQ and its powerful type-safe querying capabilities, like window functions, common table expressions, upsert, stored procedures and database functions.

Unit Testing: Principles, Practices and Patterns is a practical guide to modern unit testing best practices. Microsoft MVP Vladimir Khorikov takes you hands-on with examples of the ideal unit test and unit testing practices, building your skills step by step on a solid foundation. You’ll explore how to design and write tests that check the right aspects of your applications, develop effective and maintainable test suites, and automate your testing process safely. When you are done, you will have a best practice testing suite that ensures your projects are easier to maintain, easier to scale, and easier to adapt to changing needs.
what's inside
A universal frame of reference by which to assess any unit test
Common anti-patterns to identify and avoid
Guidelines on how to refactor a test suite along with the production code it covers
Using integration tests to verify the behavior of the system as a whole

Human-in-the-Loop Machine Learning is a guide to optimizing the human and machine parts of your machine learning systems, to ensure that your data and models are correct, relevant, and cost-effective. 20-year machine learning veteran Robert Munro lays out strategies to get machines and humans working together efficiently, including building reliable user interfaces for data annotation, Active Learning strategies to sample for human feedback, and Transfer Learning. By the time you’re done, you’ll be able to design machine learning systems that automatically select the right data for humans to review and ensure that those annotations are accurate and useful.
what's inside
Active Learning to sample the right data for humans to annotate
Annotation strategies to provide the optimal interface for human feedback
Techniques to select the right people to annotate data and ensure quality control
Supervised machine learning design and query strategies to support Human-in-the-Loop systems
Advanced Adaptive Learning approaches that use machine learning to optimize each step in the Human-in-the-Loop process
Real-world use cases from well-known data scientists

Real-world Natural Language Processing teaches you how to create practical NLP applications using Python and open source NLP libraries such as AllenNLP and Fairseq. In this practical guide, you’ll begin by creating a complete sentiment analyzer, then dive deep into each component to unlock the building blocks you’ll use in all different kinds of NLP programs. By the time you’re done, you’ll have the skills to create named entity taggers, machine translation systems, spelling correctors, and language generation systems.
what's inside
Design, develop, and deploy basic NLP applications
NLP libraries such as AllenNLP and Fairseq
Advanced NLP concepts such as attention and transfer learning

In Microservices: A Practical Guide, architecture expert Eberhard Wolff starts by introducing microservices, self-contained systems, and the migration to microservices architecture. You’ll then move on to cookbook-style recipes that answer the most common challenges and operations of implementing microservices, including client-side and server-side frontend integration, asynchronous microservices, synchronous systems, and utilizing microservices platforms such as Kubernetes, Istio, and Cloud Foundry. Each recipe is fully illustrated with demo code and suggested variations that make them easy to adapt to your needs. By the time you’re done, you’ll have the skills to start implementing microservices architecture and a handy guide to consult as you work.
what's inside
Migrating to microservices
Frontend Integration with JavaScript and Edge Side Includes
Asynchronous microservices with Apache Kafka or REST/Atom
Synchronous microservices with the Netflix Stack or Consul
Microservice platforms: Kubernetes, Cloud Foundry, or Istio
Monitoring with Prometheus
Log Analysis with Elasticsearch and Kibana
Tracing with Zipkin

Coding and testing are often considered separate areas of expertise. In this comprehensive guide, author and Java expert Scott Oaks takes the approach that anyone who works with Java should be equally adept at understanding how code behaves in the JVM, as well as the tunings likely to help its performance.
You’ll gain in-depth knowledge of Java application performance, using the Java Virtual Machine (JVM) and the Java platform, including the language and API. Developers and performance engineers alike will learn a variety of features, tools, and processes for improving the way Java 7 and 8 applications perform.
Apply four principles for obtaining the best results from performance testing
Use JDK tools to collect data on how a Java application is performing
Understand the advantages and disadvantages of using a JIT compiler
Tune JVM garbage collectors to affect programs as little as possible
Use techniques to manage heap memory and JVM native memory
Maximize Java threading and synchronization performance features
Tackle performance issues in Java EE and Java SE APIs
Improve Java-driven database application performance

Get more out of your legacy systems: more performance, functionality, reliability, and manageability

Is your code easy to change? Can you get nearly instantaneous feedback when you do change it? Do you understand it? If the answer to any of these questions is no, you have legacy code, and it is draining time and money away from your development efforts.

In this book, Michael Feathers offers start-to-finish strategies for working more effectively with large, untested legacy code bases. This book draws on material Michael created for his renowned Object Mentor seminars: techniques Michael has used in mentoring to help hundreds of developers, technical managers, and testers bring their legacy systems under control.

The topics covered include

Understanding the mechanics of software change: adding features, fixing bugs, improving design, optimizing performance
Getting legacy code into a test harness
Writing tests that protect you against introducing new problems
Techniques that can be used with any language or platform—with examples in Java, C++, C, and C#
Accurately identifying where code changes need to be made
Coping with legacy systems that aren't object-oriented
Handling applications that don't seem to have any structure
This book also includes a catalog of twenty-four dependency-breaking techniques that help you work with program elements in isolation and make safer changes.



© Copyright Pearson Education. All rights reserved.

It's not easy to design good application interfaces in a world where companies must create compelling, seamless user experiences across an exploding number of channels, screens, and contexts. Design patterns, design systems, and component-based UI frameworks have emerged and now rapidly evolve to meet the challenge.
This bestselling book is one of the few reliable sources to help you navigate through the maze of design options. By capturing UI best practices and reusable ideas as design patterns, Designing Interfaces provides solutions to common design problems that you can tailor to the situation at hand.
This updated edition includes patterns for mobile apps and social media, as well as web applications and desktop software. Each pattern contains full-color examples and practical design advice that you can use immediately. Experienced designers can use this guide as a sourcebook of ideas; novices will find a roadmap to the world of interface and interaction design.

Deep learning is changing everything. This machine-learning method has already surpassed traditional computer vision techniques, and the same is happening with NLP. If you're looking to bring deep learning into your domain, this practical book will bring you up to speed on key concepts using Facebook's PyTorch framework.
Once author Ian Pointer helps you set up PyTorch on a cloud-based environment, you'll learn how use the framework to create neural architectures for performing operations on images, sound, text, and other types of data. By the end of the book, you'll be able to create neural networks and train them on multiple types of data.
Learn how to deploy deep learning models to production
Explore PyTorch use cases in companies other than Facebook
Learn how to apply transfer learning to images
Apply cutting-edge NLP techniques using a model trained on Wikipedia

Programming with Types teaches you to design safe, resilient, correct software that’s easy to maintain and understand by taking advantage of the power of strong type systems. Designed to provide practical, instantly-useful techniques for working developers, this clearly-written tutorial introduces you to using type systems to support everyday programming tasks. In it, you’ll explore the impact types have on functions, inheritance, and composition, and you’ll take a close look at generics, which enable greater abstraction. You’ll also discover folding data structures and applying functions to containers with higher kinded types. Along the way, you’ll explore real-world use cases and practical examples in TypeScript as you build your skills from primitive types up to more advanced concepts like functors and monads.
what's inside
An introduction to type systems and their benefits
Designing functions that don’t return values
Encoding text
Building data structures with arrays and references
Type composition
Function types
Type safety
Asynchronous functions
Subtyping
Object-oriented programming with types
Generic data structures and algorithms

Get Programming with Clojure guides you through exercises, examples, and projects that teach you to build fast, robust, applications with Clojure. Under Yehonathan Sharvit’s expert instruction, you’ll begin by getting comfortable with Clojure’s Lisp-y syntax. Then, you’ll start writing short programs that introduce functional programming principles like immutability, data-orientation, and first-class functions. After two or three small projects, you’ll be ready to drill down to more advanced concepts including logic operations, vectors and maps, lazy sequences, pure and high-order functions, and state management.
Throughout this hands-on book, you’ll work with the custom interactive Klipse Clojure REPL environment—developed by the author himself!—where you’ll quickly appreciate the productivity benefits of evaluating and modifying expressions from the command line. Capstone projects at the end of each set of short, focused lessons seal in all you’ve learned. You’ll grow your skills step-by-step as you explore building and deploying a Clojure program that handles real-life challenges like the management of a bank account. By the end of the book, you’ll be well-prepared to move on to developing ecommerce web servers, writing front-end apps, publishing your own Clojure libraries, and more!
what's inside
Mastering Clojure syntax
Working with immutable data collections
Functions as first-class objects
Evaluating expressions in the Clojure REPL environment
Composing a pipeline for manipulating data
Capstone projects ranging from a bank account manager to a string composer

Deep Learning for Natural Language Processing teaches you to apply state-of-the-art deep learning approaches to natural language processing tasks. You’ll learn key NLP concepts like neural word embeddings, auto-encoders, part-of-speech tagging, parsing, and semantic inference. Then you’ll dive deeper into advanced topics including deep memory-based NLP, linguistic structure, and hyperparameters for deep NLP. Along the way, you’ll pick up emerging best practices and gain hands-on experience with a myriad of examples, all written in Python and the powerful Keras library. By the time you’re done reading this invaluable book, you’ll be solving a wide variety of NLP problems with cutting-edge deep learning techniques!
what's inside
An overview of NLP and deep learning
One-hot text representations
Word embeddings
Models for textual similarity
Sequential NLP
Semantic role labeling
Deep memory-based NLP
Linguistic structure
Hyperparameters for deep NLP

Graph Databases in Action teaches you everything you need to know to begin building and running applications powered by graph databases. Right off the bat, seasoned graph database experts and authors Dave Bechberger and Josh Perryman introduce you to just enough graph theory, the graph database ecosystem, and a variety of datastores. You’ll also explore modelling basics in action with real-world examples, then go hands-on with querying, coding traversals, parsing results, and other essential tasks as you build your own graph-backed social network app complete with a recommendation engine!
With valuable firsthand experience under your belt, you’re ready for advanced concepts including query tuning, data model tuning, evolving your graphs, and pitfalls and anti-patterns like supernodes, hidden entities, and anemic edges. All examples are presented in the open source Apache TinkerPop framework and the Gremlin language, and almost all concepts and constructs are compatible with Cypher/openCypher databases such as Neo4j. With this comprehensive guide, you’ll be building graph-powered applications that dramatically increase the value of data—as well as your professional value to the companies savvy enough to use them!
what's inside
Graph database fundamentals
An overview of the graph database ecosystem
Relational vs. graph database modelling
Querying graphs using Gremlin
Real-world common graph use cases
Basic graph algorithms
A hands-on graph-backed application project
Performance tuning
Pitfalls and anti-patterns
Graph analytics

Turn the corner from “Haskell student” to “Haskell developer.” Haskell in Depth explores the important language features and programming skills you’ll need to build production-quality software using Haskell. And along the way, you’ll pick up some interesting insights into why Haskell looks and works the way it does. Get ready to go deep!
Haskell in Depth is the perfect second book on Haskell. After a quick refresher on Haskell basics, this hands-on guide dives into examples and application scenarios designed to teach how Haskell works and how to apply it correctly. You’ll learn about managing projects with Cabal and Stack, tackle error-handling and testing, and package programs and libraries for production deployment.
You’ll appreciate coverage of advanced Haskell features including programming polymorphically, working effectively with types, concurrent programming, data processing, web services, and more. Because it’s organized to make specific topics easy to find, you’ll return to this book again and again as your go-to Haskell reference.

Algorithms and Data Structures in Action introduces you to a diverse range of algorithms you’ll use in web applications, systems programming, and data manipulation. Chapter-by-chapter, the book expands on the basic algorithms you’ll already know to give you a better selection of solutions to different programming problems. In it, you’ll discover techniques for improving priority queues, efficient caching, clustering data, and more. Each example is fully illustrated with graphics, language-agnostic pseudo-code, and code samples in various languages. When you’re done, you will be able to implement advanced and little-known algorithms to deliver better performance from your code. You’ll even have the skills to design your own data structures to solve those cases when a custom solution is required.
what's inside
Improving on basic data structures
Efficient caching
Nearest neighbour search, including k-d trees and S-trees
Full ‘pseudo-code’ and samples in multiple languages