* Create your own data acquisition system independently using LabVIEW and build interactive dashboards
* Collect data using National Instrument's and third-party, open source, affordable hardware
* Step-by-step real-world examples using various tools that illustrate the fundamentals of more » data acquisition
NI LabVIEW's intuitive graphical interface eliminates the steep learning curve associated with text-based languages such as C or C++. LabVIEW is a proven and powerful integrated development environment to interact with measurement and control hardware, analyze data, publish results, and distribute systems. LabVIEW is one of the most popular types of software for data acquisition and analysis in all fields because of its graphical programming-based approach.
This hands-on tutorial, to helps you harness the power of LabVIEW for data acqusition. This book begins with a quick introduction to LabVIEW, familiarizing you with the basics of it. It provides information about the fundamentals of communication, telling you how to connect your system, which has LabVIEW installed, with other devices you are collecting data from.
The book then unleashes the power of the auto-code generation feature of LabVIEW using its GUI interface. You will learn how to use NI-DAQmax Data acquisition VIs, showing how LabVIEW can be used to appropriate a true physical phenomenon (such as temperature, light, and so on) and convert it to an appropriate data type that can be manipulated and analyzed with a computer. You will also learn how to create Distribution Kit for LabVIEW, acquainting yourself with various debugging techniques offered by LabVIEW to help you in situations where bugs are not letting you run your programs as intended.
By the end of the book, you will have a clear idea how to build your own data acquisition system independently and much more.
WHAT YOU WILL LEARN
* Create a virtual instrument which highlights common functionality of LabVIEW
* Get familiarized with common buses such as Serial, GPIB, and SCPI commands
* Staircase signal acquisition using NI-DAQmx
* Discover how to measure light intensity and distance
* Master LabVIEW debugging techniques
* Build a data acquisition application complete with an installer and required drivers
* Utilize open source microcontroller Arduino and a 32-bit Arduino compatible Uno32 using LabVIEW programming environment
ABOUT THE AUTHOR
Behzad Ehsani is a Bachelor of Science in Computer Engineering from California State University (CSUS) with over fourteen years of engineering experience in various sectors of the industry. Starting at Packard-Bell and Apple Computers and moving on to Laser, Communications and Sensors industry, the author has solid experience in system instrumentation and data acquisition system. « less
Get up and running fast with the basics of programming using Java as an example language. This short book gets you thinking like a programmer in an easy and entertaining way. Modern Programming Made Easy teaches you basic coding principles, including working with lists, sets, arrays, and maps; coding more » in the object-oriented style; and writing a web application.
What You'll Learn
* Code using the functional programming style
* Build and test your code
* Read and write from files
* Design user interfaces
* Deploy your app in the cloud
Who This Book Is For
Anyone who wants to learn how to code. Whether you're a student, a teacher, looking for a career change, or just a hobbyist, this book is made for you. « less
* Get a thorough introduction to Kotlin
* Learn to use Java code alongside Kotlin without any hiccups
* Get a complete overview of null safety, Generics, and many more interesting features
Kotlin has been making waves ever since it was open sourced by JetBrains in more » 2011; it has been praised by developers across the world and is already being adopted by companies. This book provides a detailed introduction to Kotlin that shows you all its features and will enable you to write Kotlin code to production.
We start with the basics: get you familiar with running Kotlin code, setting up, tools, and instructions that you can use to write basic programs. Next, we cover object oriented code: functions, lambdas, and properties – all while using Kotlin's new features.
Then, we move on to null safety aspects and type parameterization. We show you how to destructure expressions and even write your own. We also take you through important topics like testing, concurrency, microservices, and a whole lot more. By the end of this book you will be able to compose different services and build your own applications.
WHAT YOU WILL LEARN
* Use new features to write structured and readable object-oriented code
* Find out how to use lambdas and higher order functions to write clean, reusable, and simple code
* Write unit tests and integrate Kotlin tests with Java code in a transitioning code base
* Write real-world production code in Kotlin in the style of microservices
* Leverage Kotlin's extensions to the Java collections library
* Use destructuring expressions and find out how to write your own
* Write code that avoids null pointer errors and see how Java-nullable code can integrate with features in a Kotlin codebase
* Discover how to write functions in Kotlin, see the new features available, and extend existing libraries
* Learn to write an algebraic data types and figure out when they should be used
ABOUT THE AUTHOR
Stephen Samuel is an accomplished developer with over 17 years of experience. He has worked with Java throughout his career, and in the past 5 years has focused on Scala. He has a passion for concurrency and Big Data technologies. Having spent the last few years in investment banking, he is currently working with Kotlin on a major Big Data ingestment project. Stephen is also active in the open source community, being the author of several high profile Scala and Kotlin libraries.
Stefan Bocutiu is a Big Data consultant with over 13 years of experience in software development. He enjoys coding in Scala, C#, and has a passion for stream processing technologies. With the team at DataMountaineer--a consultancy company offering delivery of solutions for streaming/ fast data platforms - he focuses on providing scalable, unified, real-time data pipelines allowing reactive decision making, analytics, and Hadoop integration.
Stefan is passionate about motorsports, and while his racing skills are not good enough to allow him to compete, he tries to attend as many MotoGP races as possible. When he is not coding, he can be found at the climbing wall or at the gym. Occasionally, hiking and scrambling trips are on his calendar, and during the winter season, skiing trips are a must for him.
TABLE OF CONTENTS
1. Getting Started with Kotlin
2. Kotlin Basics
3. Object-Oriented Programming in Kotlin
4. Functions in Kotlin
5. Higher Order Functions and Functional Programming
7. Null Safety, Reflection, and Annotations
9. Data Classes
11. Testing in Kotlin
12. Microservices with Kotlin
13. Concurrency « less
Getting Started in Functional Programming
Smooth, powerful, and small, the Elixir programming language is an excellent place for newcomers to learn about functional programming. This book shows readers how Elixir combines the robust functional programming of Erlang with an approach that looks more like Ruby. Readers will learn how Elixir simplifies more » some of Erlang's odder corners and reaches toward metaprogramming with powerful macro features.
Introducing Elixer is ideal for developers new to programming as well as experienced developers who want to move into functional programming.
* Get comfortable with IEx, Elixir's command line interface
* Become familiar with Elixir’s basic structures by working with numbers
* Discover atoms, pattern matching, and guards: the foundations of your program structure
* Delve into the heart of Elixir processing with recursion, strings, lists, and higher-order functions
* Create processes, send messages among them, and apply pattern matching to incoming messages
* Store and manipulate structured data with Erlang Term Storage (ETS) and the Mnesia database
* Build resilient applications with the Open Telecom Platform (OTP)
* Define macros with Elixir's meta-programming tools « less
Leverage the power of Julia to design and develop high performing programs
ABOUT THIS BOOK
* Get to know the best techniques to create blazingly fast programs with Julia
* Stand out from the crowd by developing code that runs faster than your peers' code
* Complete an extensive data science project through the entire cycle from ETL to analytics and data visualization
WHO more » THIS BOOK IS FOR
This learning path is for data scientists and for all those who work in technical and scientific computation projects. It will be great for Julia developers who are interested in high-performance technical computing.
This learning path assumes that you already have some basic working knowledge of Julia's syntax and high-level dynamic languages such as MATLAB, R, Python, or Ruby.
WHAT YOU WILL LEARN
* Set up your Julia environment to achieve the highest productivity
* Solve your tasks in a high-level dynamic language and use types for your data only when needed
* Apply Julia to tackle problems concurrently and in a distributed environment
* Get a sense of the possibilities and limitations of Julia's performance
* Use Julia arrays to write high performance code
* Build a data science project through the entire cycle of ETL, analytics, and data visualization
* Display graphics and visualizations to carry out modeling and simulation in Julia
* Develop your own packages and contribute to the Julia Community
In this learning path, you will learn to use an interesting and dynamic programming language—Julia! You will get a chance to tackle your numerical and data problems with Julia. You'll begin the journey by setting up a running Julia platform before exploring its various built-in types. We'll then move on to the various functions and constructs in Julia. We'll walk through the two important collection types—arrays and matrices in Julia.
You will dive into how Julia uses type information to achieve its performance goals, and how to use multiple dispatch to help the compiler emit high performance machine code. You will see how Julia's design makes code fast, and you'll see its distributed computing capabilities.
By the end of this learning path, you will see how data works using simple statistics and analytics, and you'll discover its high and dynamic performance—its real strength, which makes it particularly useful in highly intensive computing tasks.
This learning path combines some of the best that Packt has to offer in one complete, curated package. It includes content from the following Packt products:
* Getting Started with Julia by Ivo Balvaert
* Julia High Performance by Avik Sengupta
* Mastering Julia by Malcolm Sherrington
STYLE AND APPROACH
This hands-on manual will give you great explanations of the important concepts related to Julia programming. « less
*** Key Features ***
* Explore the functional paradigms of programming with Elixir through use of helpful examples
* Concise step-by-step instructions to teach you difficult technical concepts
* Bridge the gap between functional programming and Elixir
*** Book Description ***
Elixir, based more » on Erlang's virtual machine and ecosystem, makes it easier to achieve scalability, concurrency, fault tolerance, and high availability goals that are pursued by developers using any programming language or programming paradigm. Elixir is a modern programming language that utilizes the benefits offered by Erlang VM without really incorporating the complex syntaxes of Erlang.
Learning to program using Elixir will teach many things that are very beneficial to programming as a craft, even if at the end of the day, the programmer isn't using Elixir. This book will teach you concepts and principles important to any complex, scalable, and resilient application. Mostly, applications are historically difficult to reason about, but using the concepts in this book, they will become easy and enjoyable. It will teach you the functional programing ropes, to enable them to create better and more scalable applications, and you will explore how Elixir can help you achieve new programming heights. You will also glean a firm understanding of basics of OTP and the available generic, provided functionality for creating resilient complex systems. Furthermore, you will learn the basics of metaprogramming: modifying and extending Elixir to suite your needs.
*** What you will learn ***
* Explore Elixir to create resilient, scalable applications
* Create fault-tolerant applications
* Become better acquainted with Elixir code and see how it is structured to build and develop functional programs
* Learn the basics of functional programming
* Gain an understanding of effective OTP principles
* Design program-distributed applications and systems
* Write and create branching statements in Elixir
* Learn to do more with less using Elixir's metaprogramming
* Be familiar with the facilities Elixir provides for metaprogramming, macros, and extending the Elixir language
*** About the Author ***
Kenny Ballou is a life-long learner, developer, mathematician, and overall thinker. He enjoys solving problems, learning about technologies, and discussing new and different ideas.
He graduated from the Boise State University, majoring in applied mathematics, and minoring in computer science. He has been programming professionally for nearly a decade, and is currently working as a software developer for an analytics company in the Boise, Idaho area.
Apart from developing professionally, he is active in the open source community, contributing where he can.
When he is not developing, he enjoys reading, learning, and shredding the local mountains.
You can read more from him on his blog at https://kennyballou.com, check out his code on GitHub at https://github.com/kennyballou/, and follow him on Twitter at @kennyballou.
*** Table of Contents ***
1. Introducing Elixir – Thinking Functionally
2. Elixir Basics – Foundational Steps toward Functional Programming
3. Modules and Functions – Creating Functional Building Blocks
4. Collections and Stream Processing
5. Control Flow – Occasionally You Need to Branch
6. Concurrent Programming – Using Processes to Conquer Concurrency
7. OTP – A Poor Name for a Rich Framework
8. Distributed Elixir – Taking Concurrency to the Next Node
9. Metaprogramming – Doing More with Less « less
Explore functional programming without the academic overtones (tell me about monads just one more time). Create concurrent applications, but get them right without all the locking and consistency headaches. Meet Elixir, a modern, functional, concurrent language built on the rock-solid Erlang VM. Elixir's more » pragmatic syntax and built-in support for metaprogramming will make you productive and keep you interested for the long haul. Maybe the time is right for the Next Big Thing. Maybe it's Elixir. This book is the introduction to Elixir for experienced programmers, completely updated for Elixir 1.3.
Functional programming techniques help you manage the complexities of today's real-world, concurrent systems; maximize uptime; and manage security. Enter Elixir, with its modern, Ruby-like, extendable syntax, compile and runtime evaluation, hygienic macro system, and more. But, just as importantly, Elixir brings a sense of enjoyment to parallel, functional programming. Your applications become fun to work with, and the language encourages you to experiment.
Part 1 covers the basics of writing sequential Elixir programs. We'll look at the language, the tools, and the conventions. Part 2 uses these skills to start writing concurrent code-applications that use all the cores on your machine, or all the machines on your network! And we do it both with and without OTP. Part 3 looks at the more advanced features of the language, from DSLs and code generation toextending the syntax.
This edition is fully updated with all the new features of Elixir 1.3, with a new chapter on Tooling, covering testing (both conventional and property based), code and dependency exploration, and servermonitoring.By the end of this book, you'll understand Elixir, and know how to apply it to solve your complex, modern problems.
What You Need:
You'll need a computer, a little experience with another high-level language, and a sense of adventure. No functional programming experience is needed. « less
This practical book introduces systems programmers to Rust, the new and cutting-edge language that’s still in the experimental/lab stage. You’ll learn how Rust offers the rare and valuable combination of statically verified memory safety and low-level control—imagine C++, but without dangling pointers, more » null pointer dereferences, leaks, or buffer overruns.
Author Jim Blandy—the maintainer of GNU Emacs and GNU Guile—demonstrates how Rust has the potential to be the first usable programming language that brings the benefits of an expressive modern type system to systems programming. Rust’s rules for borrowing, mutability, ownership, and moves versus copies will be unfamiliar to most systems programmers, but they’re key to Rust’s unique advantages.
This book presents Rust’s rules clearly and economically; elaborates on their consequences; and shows you how to express the programs you want to write in terms that Rust can prove are free of broad classes of everyday errors. « less
The Little Elixir & OTP Guidebook gets you started programming applications with Elixir and OTP. You begin with a quick overview of the Elixir language syntax, along with just enough functional programming to use it effectively. Then, you'll dive straight into OTP and learn how it helps you more » build scalable, fault-tolerant and distributed applications through several fun examples.
About the Technology
Elixir is an elegant programming language that combines the expressiveness of Ruby with the concurrency and fault-tolerance of Erlang. It makes full use of Erlang's BEAM VM and OTP library, so you get two decades' worth of maturity and reliability right out of the gate. Elixir's support for functional programming makes it perfect for modern event-driven applications.
About the Book
The Little Elixir & OTP Guidebook gets you started writing applications with Elixir and OTP. You'll begin with the immediately comfortable Elixir language syntax, along with just enough functional programming to use it effectively. Then, you'll dive straight into several lighthearted examples that teach you to take advantage of the incredible functionality built into the OTP library.
* Covers Elixir 1.2 and 1.3
* Introduction to functional concurrency with actors
* Experience the awesome power of Erlang and OTP
About the Reader
Written for readers comfortable with a standard programming language like Ruby, Java, or Python. FP experience is helpful but not required.
About the Author
Benjamin Tan Wei Hao is a software engineer at Pivotal Labs, Singapore. He is also an author, a speaker, and an early adopter of Elixir.
Table of Contents
1. GETTING STARTED WITH ELIXIR AND OTP
3. A whirlwind tour
4. Processes 101
5. Writing server applications with GenServer
6. FAULT TOLERANCE, SUPERVISION, AND DISTRIBUTION
7. Concurrent error-handling and fault tolerance with links, monitors, and processes
8. Fault tolerance with Supervisors
9. Completing the worker-pool application
10. Distribution and load balancing
11. Distribution and fault tolerance
12. Dialyzer and type specifications
13. Property-based and concurrency testing « less
Leverage the features of TypeScript to boost your development skills and create captivating applications
ABOUT THIS BOOK
* Learn how to develop modular, scalable, maintainable, and adaptable web applications by taking advantage of TypeScript
* Explore techniques to use TypeScript alongside other leading tools such as Angular 2, React, and Node.js
* Focusing on design patterns in TypeScript, this step-by-step more » guide demonstrates all the important design patterns in practice
WHO THIS BOOK IS FOR
WHAT YOU WILL LEARN
* Understand the key TypeScript language features and runtime
* Install and configure the necessary tools in order to start developing an application
* Create object-oriented code that adheres to the SOLID principles
* Develop robust applications with testing (Mocha, Chai, and SinonJS)
* Apply GoF patterns in an application with a testing approach
* Identify the challenges when developing an application
* Utilize System.JS and Webpack to load scripts and their dependencies
* Develop high performance server-side applications to run within Node.js
The first module gets you started with TypeScript and helps you understand the basics of TypeScript and automation tools. Get a detailed description of function, generics, callbacks, and promises, and discover the object-oriented features and memory management functionality of TypeScript.
The next module starts by explaining the current challenges when designing and developing an application and how you can solve these challenges by applying the correct design pattern and best practices. You will be introduced to low-level programming concepts to help you write TypeScript code, as well as working with software architecture, best practices, and design aspects.
By the end of this Learning Path, you will be able to take your skills up a notch and develop full-fledged web applications using the latest features of the TypeScript.
This Learning Path combines some of the best that Packt has to offer in one complete, curated package. It includes content from the following Packt products:
* Learning TypeScript by Remo H. Jansen
* TypeScript Design Patterns by Vilic Vane
* TypeScript Blueprints by Ivo Gabe de Wolff
STYLE AND APPROACH
This is a step-by-step, practical guide covering the fundamentals of TypeScript with practical examples. The end-to-end projects included in this book will give you ready-to-implement solutions for your business scenario, showcasing the depth and robustness of TypeScript. « less