Now that machine learning is thriving, even programmers who know close to nothing about this technology can use simple, efficient tools to implement programs capable of learning from data. This practical book shows you how.By using concrete examples, minimal theory, and two production-ready Python frameworks—Scikit-Learn and TensorFlow—author Aurélien Géron helps you gain an intuitive understanding of the concepts and tools for building intelligent systems. You’ll learn how to use a range of techniques, starting with simple Linear Regression and progressing to Deep Neural Networks. If you have some programming experience and you’re ready to code a machine learning project, this guide is for you.This hands-on book shows you how to use:Scikit-Learn, an accessible framework that implements many algorithms efficiently and serves as a great machine learning entry pointTensorFlow, a more complex library for distributed numerical computation, ideal for training and running very large neural networksPractical code examples that you can apply without learning excessive machine learning theory or algorithm details

    It is the technology behind photo tagging systems at Facebook and Google, self-driving cars, speech recognition systems on your smartphone, and much more.In particular, Deep learning excels at solving machine perception problems: understanding the content of image data, video data, or sound data. Here's a simple example: say you have a large collection of images, and that you want tags associated with each image, for example, "dog," "cat," etc. Deep learning can allow you to create a system that understands how to map such tags to images, learning only from examples. This system can then be applied to new images, automating the task of photo tagging. A deep learning model only has to be fed examples of a task to start generating useful results on new data.

    Each layer in their application is decoupled from other layers so they can scale, update, and maintain them independently.Kubernetes in Action teaches developers how to use Kubernetes to deploy self-healing scalable distributed applications. By the end, readers will be able to build and deploy applications in a proper way to take full advantage of the Kubernetes platform.Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

    Discover the “hidden gold” in Python’s standard library and start writing clean and Pythonic code today. Who Should Read This Book: If you’re wondering which lesser known parts in Python you should know about, you’ll get a roadmap with this book. Discover cool (yet practical!) Python tricks and blow your coworkers’ minds in your next code review. If you’ve got experience with legacy versions of Python, the book will get you up to speed with modern patterns and features introduced in Python 3 and backported to Python 2. If you’ve worked with other programming languages and you want to get up to speed with Python, you’ll pick up the idioms and practical tips you need to become a confident and effective Pythonista. If you want to make Python your own and learn how to write clean and Pythonic code, you’ll discover best practices and little-known tricks to round out your knowledge. What Python Developers Say About The Book: "I kept thinking that I wished I had access to a book like this when I started learning Python many years ago." — Mariatta Wijaya, Python Core Developer"This book makes you write better Python code!" — Bob Belderbos, Software Developer at Oracle"Far from being just a shallow collection of snippets, this book will leave the attentive reader with a deeper understanding of the inner workings of Python as well as an appreciation for its beauty." — Ben Felder, Pythonista"It's like having a seasoned tutor explaining, well, tricks!" — Daniel Meyer, Sr. Desktop Administrator at Tesla Inc.

    How was Wolfenstein 3D made and what were the secrets of its speed? How did id Software manage to turn a machine designed to display static images for word processing and spreadsheet applications into the best gaming platform in the world, capable of running games at seventy frames per seconds? If you have ever asked yourself these questions, Game Engine Black Book is for you.

    Domain-driven design (DDD) combined with functional programming is the innovative combo that will get you there. In this pragmatic, down-to-earth guide, you'll see how applying the core principles of functional programming can result in software designs that model real-world requirements both elegantly and concisely - often more so than an object-oriented approach. Practical examples in the open-source F# functional language, and examples from familiar business domains, show you how to apply these techniques to build software that is business-focused, flexible, and high quality.Domain-driven design is a well-established approach to designing software that ensures that domain experts and developers work together effectively to create high-quality software. This book is the first to combine DDD with techniques from statically typed functional programming. This book is perfect for newcomers to DDD or functional programming - all the techniques you need will be introduced and explained.Model a complex domain accurately using the F# type system, creating compilable code that is also readable documentation---ensuring that the code and design never get out of sync. Encode business rules in the design so that you have "compile-time unit tests," and eliminate many potential bugs by making illegal states unrepresentable. Assemble a series of small, testable functions into a complete use case, and compose these individual scenarios into a large-scale design. Discover why the combination of functional programming and DDD leads naturally to service-oriented and hexagonal architectures. Finally, create a functional domain model that works with traditional databases, NoSQL, and event stores, and safely expose your domain via a website or API.Solve real problems by focusing on real-world requirements for your software.What You Need: The code in this book is designed to be run interactively on Windows, Mac and Linux.You will need a recent version of F# (4.0 or greater), and the appropriate .NET runtime for your platform.Full installation instructions for all platforms at fsharp.org.

    "Uncle Bob" Martin shows how to bring greater professionalism and discipline to application architecture and design.As with his other books, Martin's Clean Architecture doesn't merely present multiple choices and options, and say "use your best judgment": it tells you what choices to make, and why those choices are critical to your success. Martin offers direct, no-nonsense answers to key architecture and design questions like:What are the best high level structures for different kinds of applications, including web, database, thick-client, console, and embedded apps?What are the core principles of software architecture?What is the role of the architect, and what is he/she really trying to achieve?What are the core principles of software design?How do designs and architectures go wrong, and what can you do about it?What are the disciplines and practices of professional architects and designers?Clean Architecture is essential reading for every software architect, systems analyst, system designer, and software manager — and for any programmer who aspires to these roles or is impacted by their work.

    If you have received one of these copies, please contact the Pragmatic Bookshelf at support@pragprog.com, and we will replace it for you.Algorithms and data structures are much more than abstract concepts. Mastering them enables you to write code that runs faster and more efficiently, which is particularly important for today's web and mobile apps. This book takes a practical approach to data structures and algorithms, with techniques and real-world scenarios that you can use in your daily production code. Graphics and examples make these computer science concepts understandable and relevant. You can use these techniques with any language; examples in the book are in JavaScript, Python, and Ruby.Use Big O notation, the primary tool for evaluating algorithms, to measure and articulate the efficiency of your code, and modify your algorithm to make it faster. Find out how your choice of arrays, linked lists, and hash tables can dramatically affect the code you write. Use recursion to solve tricky problems and create algorithms that run exponentially faster than the alternatives. Dig into advanced data structures such as binary trees and graphs to help scale specialized applications such as social networks and mapping software. You'll even encounter a single keyword that can give your code a turbo boost. Jay Wengrow brings to this book the key teaching practices he developed as a web development bootcamp founder and educator.Use these techniques today to make your code faster and more scalable.

    Their applications range from network routing and computational genomics to public-key cryptography and database system implementation. Studying algorithms can make you a better programmer, a clearer thinker, and a master of technical interviews. Algorithms Illuminated is an accessible introduction to the subject---a transcript of what an expert algorithms tutor would say over a series of one-on-one lessons. The exposition is rigorous but emphasizes the big picture and conceptual understanding over low-level implementation and mathematical details. Part 1 of the book series covers asymptotic analysis and big-O notation, divide-and-conquer algorithms and the master method, randomized algorithms, and several famous algorithms for sorting and selection.

    This book uses the common sense of these roads and weaves it into the implementation of an attractive app. You will build a Hacker News React app. On the road you will learn ES6, React with all its basics and advanced concepts and internal state management.' to 'A lot of roadmaps exist on how to master React. This book uses the common sense of these roads and weaves it into the implementation of an attractive app. You will build a Hacker News React app. On the road you will learn ES6, React with all its basics and advanced concepts and internal state management. http://www.robinwieruch.de/the-road-t...

    We have put thousands of hours into the fourth edition of the book, writing and revising its material to include significant improvements and new material based on feedback from previous editions.

    It allows us to write elegant, intention-revealing code, that shines in testability and support for concurrency. C# includes a number of functional features and libraries, enabling us to take advantage of these benefits.Functional Programming in C# teaches you to apply functional thinking to real-world scenarios. You’ll start by learning the principles of functional programming, and how they translate in the C# language. The book then dives into important topics like function composition, data flow, and principles for designing function signatures, types and collections. Through lots of real-world examples, you’ll acquire the tools to tackle programming tasks with a functional approach. The last part of the book deals with advanced topics, including lazy evaluation, stateful computations, asynchrony, and event streams. By the end of this book, you’ll be able to integrate functional techniques, making your C# programs robust and maintainable, and helping you become a more well-rounded developer.

    Since its debut in 2000, C# has become a language of unusual flexibility and breadth, but its continual growth means there's always more to learn.Organized around concepts and use cases, this updated edition provides intermediate and advanced programmers with a concise map of C# and .NET knowledge. Dive in and discover why this Nutshell guide is considered the definitive reference on C#.Get up to speed on the C# language, from the basics of syntax and variables to advanced topics such as pointers, operator overloading, and dynamic bindingDig deep into LINQ via three chapters dedicated to the topicExplore concurrency and asynchrony, advanced threading, and parallel programmingWork with .NET features, including XML, regular expressions, networking, serialization, reflection, application domains, and securityDelve into Roslyn, the modular C# 7.0 compiler-as-a-service

    It discusses architectural design and implementation approaches using .NET Core and Docker containers. To make it easier to get started with containers and microservices, the guide focuses on a reference containerized and microservice-based application that you can explore. The sample application is available at the eShopOnContainers GitHub repo.

    However, successful applications have a habit of growing. Eventually the development team ends up in what is known as monolithic hell. All aspects of software development and deployment become painfully slow. The solution is to adopt the microservice architecture, which structures an application as a services, organized around business capabilities. This architecture accelerates software development and enables continuous delivery and deployment of complex software applications.Microservice Patterns teaches enterprise developers and architects how to build applications with the microservice architecture. Rather than simply advocating for the use the microservice architecture, this clearly-written guide takes a balanced, pragmatic approach. You'll discover that the microservice architecture is not a silver bullet and has both benefits and drawbacks. Along the way, you'll learn a pattern language that will enable you to solve the issues that arise when using the microservice architecture. This book also teaches you how to refactor a monolithic application to a microservice architecture.

    This book teaches you with Idris, a language designed from the very beginning to support type-driven development. In this book, you’ll learn how to manipulate types just like any other construct (numbers, strings, lists, etc.). You’ll see how to use type-driven development to build real-world software, as well as how to handle side-effects, state and concurrency, and interoperating with existing systems. By the end of this book, you will be able to develop robust and verified software in Idris and apply type-driven development methods to programming in other languages.

    I was smart enough to earn an honors degree in philosophy from Harvard, but an aptitude test told me to avoid computer programming. I'm sure it was right. But then I designed a learning system for myself that quadrupled my aptitude for learning computer languages. It worked so well for me that I've used it to teach coding to grandmothers, cab drivers, musicians, and 50,000 other newbies. "Mark Myers' method of getting what can be...difficult information into a format that makes it exponentially easier to consume, truly understand, and synthesize into real-world application is beyond anything I've encountered before." —Amazon reviewer Jason A. Ruby reviewing my first book, A Smarter Way to Learn JavaScript Quadruple your learning ability. Washington University research shows that a key teaching method I use—interactive recall practice—improves learning performance 400 percent. "I don't feel lost and I don't feel that I am forgetting things as I go along." —Amazon reviewer Leonie M. reviewing my second book, A Smarter Way to Learn HTML and CSS Understanding is easy. Remembering is hard. Computer languages are not inherently hard to understand, even for non-techies. Remembering is the problem. If you remember all of Chapter 1 through Chapter 10, you'll understand Chapter 11. But you don't remember. Though you read and read, most of it doesn't stick. You don't have a solid foundation to build on. Halfway through the book, it all collapses. That's when most people give up."I've signed up to a few sites like Udemy, Codecademy, FreeCodeCamp, Lynda, YouTube videos, even searched on Coursera but nothing seemed to work for me. This book takes only 10 minutes each chapter and after that, you can exercise what you've just learned right away!" —Amazon reviewer Constanza Morales reviewing my first book, A Smarter Way to Learn JavaScript Interactive exercises make it stick. Research shows that you will remember everything if you're repeatedly asked to recall it. That's the beauty of flash cards. But technology offers an even better way to make information stick. With my book you get almost a thousand interactive exercises—they're free online—that embed the whole book in your memory. Algorithms check your work to make sure you know what you think you know. When you stumble, you do the exercise again. You keep trying until you know the chapter cold. "Not only do the exercises make learning fun, they reinforce the material right away so it sinks in deeper." —Amazon reviewer Timothy B. Miller reviewing my second book, A Smarter Way to Learn HTML and CSS You won't get bored or sleepy. The exercises keep you engaged, give you extra practice where you're shaky, and prepare you for each next step. Every lesson is built on top of a solid foundation that you and I have carefully constructed. Each individual step is small. But all the little steps add up to real knowledge—knowledge that you retain. I finally feel like I KNOW it and won't need to look up the syntax each time..." —Amazon reviewer J. Caritas reviewing my third book, A Smarter Way to Learn jQuery Really, it ain't that hard.

    This means designing systems as small composable units, expressing constraints and interactions via the type system, and using composition to guide the construction of large systems in a way that maintains the original architectural vision.The book also serves as an introduction to the Cats library. We use abstractions from Cats, and we explain the structure of Cats so you can use it without fear in your own code base. The broad ideas are not specific to Cats, but Cats provides an excellent implementation that is beneficial to learn in its own right.

    If you're a developer familiar with Go, this practical book demonstrates best practices and patterns to help you incorporate concurrency into your systems.Author Katherine Cox-Buday takes you step-by-step through the process. You'll understand how Go chooses to model concurrency, what issues arise from this model, and how you can compose primitives within this model to solve problems. Learn the skills and tooling you need to confidently write and implement concurrent systems of any size.Understand how Go addresses fundamental problems that make concurrency difficult to do correctlyLearn the key differences between concurrency and parallelismDig into the syntax of Go's memory synchronization primitivesForm patterns with these primitives to write maintainable concurrent codeCompose patterns into a series of practices that enable you to write large, distributed systems that scaleLearn the sophistication behind goroutines and how Go's runtime stitches everything together

    Loosely based on neuron behavior inside of human brains, these systems are rapidly catching up with the intelligence of their human creators, defeating the world champion Go player, achieving superhuman performance on video games, driving cars, translating languages, and sometimes even helping law enforcement fight crime. Deep Learning is a revolution that is changing every industry across the globe.Grokking Deep Learning is the perfect place to begin your deep learning journey. Rather than just learn the “black box” API of some library or framework, you will actually understand how to build these algorithms completely from scratch. You will understand how Deep Learning is able to learn at levels greater than humans. You will be able to understand the “brain” behind state-of-the-art Artificial Intelligence. Furthermore, unlike other courses that assume advanced knowledge of Calculus and leverage complex mathematical notation, if you’re a Python hacker who passed high-school algebra, you’re ready to go. And at the end, you’ll even build an A.I. that will learn to defeat you in a classic Atari game.

    It contains detailed explanations of the Core MVC functionality which enables developers to produce leaner, cloud optimized and mobile-ready applications for the .NET platform. This book puts ASP.NET Core MVC into context and dives deep into the tools and techniques required to build modern, cloud optimized extensible web applications. All the new MVC features are described in detail and the author explains how best to apply them to both new and existing projects.The ASP.NET Core MVC Framework is the latest evolution of Microsoft’s ASP.NET web platform, built on a completely new foundation. It represents a fundamental change to how Microsoft constructs and deploys web frameworks and is free of the legacy of earlier technologies such as Web Forms. ASP.NET Core MVC provides a "host agnostic" framework and a high-productivity programming model that promotes cleaner code architecture, test-driven development, and powerful extensibility.Best-selling author Adam Freeman has thoroughly revised this market-leading book and explains how to get the most from ASP.NET Core MVC. He starts with the nuts-and-bolts and shows you everything through to advanced features, going in-depth to give you the knowledge you need. The book includes a fully worked case study of a functioning web application that readers can use as a template for their own projects.

    Written by developers of the original Sun Certified Java Programmer exam, OCA Java SE 8 Programmer I Exam Guide (Exam 1Z0-808) includes two complete, accurate practice exams. In all, you will get more than 200 practice questions that mirror those on the actual test in content, tone, and format. Beyond fully preparing you for the challenging exam, the book also serves as an ideal on-the-job reference.Clearly explains every topic on Exam IZ0-808, including: - Declarations - Access control - Object orientation - Assignments - Operators - Flow control - Exceptions - Strings - Arrays - ArrayLists Electronic content includes: - 200+ practice exam questions - Fully customizable test engine - Secured book PDF

     Functional Programming (FP) is an incredibly powerful paradigm for structuring code that yields more robust, verifiable, and readable programs. If you've ever tried to learn FP but struggled with terms like "monad", mathematical concepts like category theory, or symbols like λ, you're not alone. Functional-Light programming distills the most vital aspects of FP—function purity, value immutability, composition, and more!—down to approachable JavaScript patterns. Rather than the all-or-nothing dogmatism often encountered in FP, this book teaches you how to improve your programs line by line.

    This definitive guide from RSpec's lead developer shows you how to use RSpec to drive more maintainable designs, specify and document expected behavior, and prevent regressions during refactoring. Build a project using RSpec to design, describe, and test the behavior of your code-whether you're new to testing tools or an experienced developer.RSpec has been downloaded more than 40 million times. Find out how to use this influential Ruby testing framework to iteratively develop a project with the confidence that comes from well-tested code. Effective Testing With RSpec 3 guides you through developing a Ruby project with RSpec, and then explores the individual components in more detail.First, learn the basics of installing and using RSpec. Then, build a real-world JSON API, using RSpec throughout the process to drive a BDD-style outside-in workflow. Apply an effective test strategy to write fast, robust tests that support evolutionary design through refactoring. The rest of the book provides the definitive guide to RSpec's components. Use RSpec:: Core's metadata to slice and dice your spec suite in flexible ways. Dig into RSpec:: Expectation's matchers, which can be composed in flexible ways to precisely specify expected outcomes and get good failure messages that help you quickly diagnose the problem. Write fast, isolated tests with RSpec:: Mocks test doubles while pushing your code toward simpler interfaces.The authors, with a combined 20 years of automated testing experience, share useful, actionable testing advice that will help you have a fun, productive testing experience.What You Need: To follow along with the book, you'll need Ruby 2.1+. The book will guide you through installing RSpec 3 and setting up a new project to use it.

    You'll even solve fun and interesting real-world problems using deep learning along the way.

    Quickly get to work - or get that job - with the right tools and the best practices.Seriously: Stop wasting your time scouring Google, searching through incorrect, out-of-date, blog posts and get everything you need to be productive in one, well-organized place. The book is complete with both simple and complex examples to get your apps up and running.You'll learn what you need to know to work professionally and build solid, well-tested, optimized apps with ReactJS. This book is your definitive guide or your money back.Buy now at https://www.fullstackreact.com.

    And how to move all of this data becomes nearly as important as the data itself. If you� re an application architect, developer, or production engineer new to Apache Kafka, this practical guide shows you how to use this open source streaming platform to handle real-time data feeds.Engineers from Confluent and LinkedIn who are responsible for developing Kafka explain how to deploy production Kafka clusters, write reliable event-driven microservices, and build scalable stream-processing applications with this platform. Through detailed examples, you� ll learn Kafka� s design principles, reliability guarantees, key APIs, and architecture details, including the replication protocol, the controller, and the storage layer.Understand publish-subscribe messaging and how it fits in the big data ecosystem.Explore Kafka producers and consumers for writing and reading messagesUnderstand Kafka patterns and use-case requirements to ensure reliable data deliveryGet best practices for building data pipelines and applications with KafkaManage Kafka in production, and learn to perform monitoring, tuning, and maintenance tasksLearn the most critical metrics among Kafka� s operational measurementsExplore how Kafka� s stream delivery capabilities make it a perfect source for stream processing systems

    Obie Fernandez illuminates the entire Rails 5 API, its most powerful idioms, design approaches, and libraries. He presents new and updated content on Action Cable, RSpec 3.4, Turbolinks 5.0, the Attributes API, and many other enhancements, both major and subtle. Through detailed code examples, you'll dive deep into Ruby on Rails, discover why it's designed as it is, and learn to make it do exactly what you want. Proven in thousands of production systems, the knowledge in this book will maximize your productivity and help you build more successful solutions. Build powerful, scalable, REST-compliant back-end services Program complex program flows using Action Controller Represent models, relationships, and operations in Active Record, and apply advanced Active Record techniques Smoothly evolve database schema via Migrations Craft front-ends with ActionView and the Asset Pipeline Optimize performance and scalability with caching and Turbolinks 5.0 Improve your productivity using Haml HTML templating Secure your systems against attacks like SQL Injection, XSS, and XSRF Integrate email using Action Mailer Enable real-time, websockets-based browser behavior with Action Cable Improve responsiveness with background processing Build "API-only" back-end projects that speak JSON Leverage enhancements to Active Job, serialization, and Ajax support

    Rx lets developers easily and quickly build apps with code that can be understood by other Rx developers - even over different platforms.Not only will you learn how to use the RxSwift port to create complex reactive applications on iOS, you'll also see how to easily solve common application design issues by using RxSwift. Finally, you'll discover how to exercise full control over the library and leverage the full power of reactive programming in your apps.Who This Book Is ForThis book is for iOS developers who already feel comfortable with iOS and Swift, and want to dive deep into development with RxSwift.Topics Covered in RxSwiftGetting Started Get an introduction to the reactive programming paradigm, learn the terminology involved and see how to begin using RxSwift in your projects.Event Management Learn how to handle asynchronous event sequences via two key concepts in Rx - Observables and Observers.Being Selective See how to work with various events using concepts such as filtering, transforming, combining, and time operators.UI Development RxSwift makes it easy to work with the UI of your apps using RxCocoa, which provides an integration of both UIKit and Cocoa.Intermediate Topics Level up your RxSwift knowledge with chapters on reactive networking, multi-threading, and error handling.Advanced Topics Round out your RxSwift education by learning about MVVM app architecture, scene-based navigation, and exposing data via services. And much, much more! By the end of this book, you'll have hands-on experience solving common issues in a reactive paradigm - and you'll be well on your way to coming up with your own Rx patterns and solutions!

    Spring Boot and Spring Cloud offer Java developers an easy migration path from traditional monolithic Spring applications to microservice-based applications that can be deployed to multiple cloud platforms. The Spring Boot and Spring Cloud frameworks let you quickly build microservices that are ready to be deployed to a private corporate cloud or a public cloud like Amazon Web Services (AWS) or Pivotal’s CloudFoundry.Spring Microservices in Action teaches you how to use the Spring Boot and Spring Cloud frameworks to build and deploy microservice-based cloud applications. You'll begin with an introduction to the microservice pattern and how to build microservices with Spring Boot and Spring Cloud. Then you'll get hands-on and discover how to configure Spring Boot. Using lots of real-world examples, you'll learn topics like service discovery with Spring Cloud, Netflix Eureka, and Ribbon. Next, you'll find out how to handle potential problems using client-side resiliency patterns with Spring and Netflix Hystrix. This book also covers implementing a service gateway with Spring Cloud and Zuul and event processing in the cloud with Spring Cloud Stream. Finally, you'll learn to deploy and push your application to cloud services, including AWS and CloudFoundry. By the end of this book, you'll not only be able to build your own microservice-based applications, but how operationalize and scale your microservices so they can deployed to a private or public cloud.

    This approach includes scaling organizations that deliver software and services. Using a microservices approach, software is composed of small independent services that communicate over well-defined APIs. These services are owned by small self-contained teams. In this whitepaper, we summarize the common characteristics of microservices, talk about the main challenges of building microservices, and describe how product teams can leverage Amazon Web Services (AWS) to overcome those challenges. This documentation is offered for free here as a Kindle book, or you can read it in PDF format at https://aws.amazon.com/whitepapers/.

    Designed for experienced IT professionals ready to advance their status, book focuses on the critical thinking and decision making acumen needed for success at the MCSA level.Covered topics focus on the expertise measured by the objectives to filter, sort, join, aggregate and modify data, use subqueries, table expressions, grouping sets and pivoting, query temporal and non-relational data, read and output XML or JSON, create views, user-defined functions and stored procedures, implement error handling, transactions, data types and nulls.

    I wrote the rampant recursive function,int fib(int n){ return (1==n || 2==n) ? 1 : fib(n-1) + fib(n-2);}and waited for the result. I wait… and wait… and wait…With an 8GB RAM and an Intel i5 CPU, why is it taking so long? I terminated the process and tried computing the 40th term. It took about a second. I put a check and was shocked to find that the above recursive function was called 204,668,309 times while computing the 40th term. More than 200 million times? Is it reporting function calls or scam of some government?The Dynamic Programming solution computes 100th Fibonacci term in less than fraction of a second, with a single function call, taking linear time and constant extra memory.A recursive solution, usually, neither pass all test cases in a coding competition, nor does it impress the interviewer in an interview of company like Google, Microsoft, etc. The most difficult questions asked in competitions and interviews, are from dynamic programming. This book takes Dynamic Programming head-on. It first explain the concepts with simple examples and then deep dives into complex DP problems.

    See how Ben Marx and Bleacher Report maintain one of the highest-traffic Elixir applications by selling the concept to management and delivering on that promise. Find out how Bruce Tate and icanmakeitbetter hire and train Elixir engineers, and the techniques they've employed to design and ensure code consistency since Elixir's early days. Explore customer challenges in deploying and monitoring distributed applications with Jose Valim and Plataformatec. This book has all the information you need to take your application from concept to production.Adoption is more than programming. Elixir is an exciting new language, but to successfully get your application from start to finish, you're going to need to know more than just the language. The case studies and strategies in this book will get you there.Make a business case and build a team before you finish your first prototype. Once you're in development, form strategies for organizing your code and learning the constraints of the runtime and ecosystem. Convince stakeholders, both business and technical, about the value they can expect. Prepare to make the critical early decisions that will shape your application for years to come. Finally, manage your deployment with all of the knobs and gauges that good DevOps teams demand. Decide between the many options available for deployment, and how to best prepare yourself for the challenges of running a production application.This book picks up where most Elixir books let off. It won't teach you to program Elixir, or any of its tools. Instead, it guides you through the broader landscape and shows you a holistic approach to adopting the language.

    Whether you’re new to coding or want to expand your skills, by the end of this course you should be able to build a fully functioning app of your own design.The course starts by introducing iOS development tools, basic programming concepts using Swift as the language, and industry best practices. Building on this foundation, you’ll follow a step-by-step curriculum, work through practical exercises, and create apps from scratch.

    Upgrade your web API to GraphQL, leveraging its flexible queries to empower your users, and its declarative structure to simplify your code. Absinthe is the GraphQL toolkit for Elixir, a functional programming language designed to enable massive concurrency atop robust application architectures. Written by the creators of Absinthe, this book will help you take full advantage of these two groundbreaking technologies. Build your own flexible, high-performance APIs using step-by-step guidance and expert advice you won't find anywhere else.GraphQL is a new way of structuring and building web services, and the result is transformational. Find out how to offer a more tailored, cohesive experience to your users, easily aggregate data from different data sources, and improve your back end's maintainability with Absinthe's declarative approach to defining how your API works.Build a GraphQL-based API from scratch using Absinthe, starting from core principles. Learn the type system and how to expand your schema to suit your application's needs. Discover a growing ecosystem of tools and utilities to understand, debug, and document your API. Take it to production, but do it safely with solid best practices in mind. Find out how complexity analysis and persisted queries can let you support your users flexibly, but responsibly too. Along the way, discover how Elixir makes all the difference for a high performance, fault-tolerant API. Use asynchronous and batching execution, or write your own custom add-ons to extend Absinthe. Go live with subscriptions, delivering data over websockets on top of Elixir (and Erlang/OTP's) famous solid performance and real-time capabilities.Transform your applications with the powerful combination of Elixir and GraphQL, using Absinthe.What You Need: To follow along with the book, you should have Erlang/OTP 19+ and Elixir 1.4+ installed. The book will guide you through setting up a new Phoenix application using Absinthe.

     The React ecosystem is huge – Redux, React Router, Webpack, Babel… Where do you even start? Most people begin by reading tutorials, but sifting through them to find the one that makes it 'click' is an exercise in frustration. On top of that, they dish out pages of code and leave it up to you to “learn by osmosis.” If you've tried to learn React on your own, you've probably had the same experience I did: after sifting through countless tutorials and video, you still can’t cobble together your own app. One second you’re nodding along, sure that you understand. The next, you’re staring at a blinking cursor wondering what to type. Thousands of people are already using React in their jobs or startups, and you can too -- once you figure it out. But what if you could skip straight to being as productive with React as you are with your current framework of choice? What if you were able to code as fast as you can think, using the JavaScript you know and love? Writing apps could be fun again! And fast. Teaching yourself React can be overwhelming… but it doesn’t have to be. You can master the fundamentals in a matter of days. Here's the thing: you need real practice. Not just nodding along to tutorials, but actually building examples and exercises. That's how you gain mastery, and this book will show you how. You’ll get hands-on practice building a series of small components and micro apps – no big monolithic app here. The bite-size apps will have you reviewing concepts until they’re second nature. With the included exercises you will be writing your own code right from the start – this isn’t a “copy, paste, watch it run” tutorial. Don't worry, we won't build any "ToDo" apps. The world already has enough of those. Learn to turn mockups directly into code, how to “think in components,” and how to handle changing state in React's world of one-way data flow. Here's what the book covers: - Easy project setup with Create React App (you’ll be running code within minutes) - Debugging strategies for when things go wrong - Mastering JSX syntax, including “if”s, loops, and dynamic child components - Using props to communicate between components, and make them as reusable as possible - How PropTypes can save you time debugging and help “future you” remember how to use the components you wrote - Using the “children” prop to render dynamic content - How to write React in the modern ES6 style, with a gentle introduction to ES6 syntax (you don't need to know ES6!) - How input controls work in React (controlled and uncontrolled) - Where and how to properly use component state in a React application - Stateful vs Stateless components - The lifecycle of a component, and how to use it to your advantage The book includes examples large and small, and 25 exercises to hone your knowledge. Buy Pure React and start learning React today!

    The first area is the data science pipeline including methodologies and the data scientist's toolbox. The second are essential practices needed in understanding the data including questions and hypotheses. The third are pitfalls to avoid in the data science process. The fourth is an awareness of future trends and how modern technologies like Artificial Intelligence (AI) fit into the data science framework.The following chapters cover these four foundational areas:Chapter 1 - What Is Data Science? Chapter 2 - The Data Science Pipeline Chapter 3 - Data Science Methodologies Chapter 4 - The Data Scientist's Toolbox Chapter 5 - Questions to Ask and the Hypotheses They Are Based On Chapter 6 - Data Science Experiments and Evaluation of Their Results Chapter 7 - Sensitivity Analysis of Experiment Conclusions Chapter 8 - Programming Bugs Chapter 9 - Mistakes Through the Data Science Process Chapter 10 - Dealing with Bugs and Mistakes Effectively and Efficiently Chapter 11 - The Role of Heuristics in Data Science Chapter 12 - The Role of AI in Data Science Chapter 13 - Data Science Ethics Chapter 14 - Future Trends and How to Remain Relevant Targeted towards data science learners of all levels, this book aims to help the reader go beyond data science techniques and obtain a more holistic and deeper understanding of what data science entails. With a focus on the problems data science tries to solve, this book challenges the reader to become a self-sufficient player in the field.

    

    The lessons are presented in a logical sequence — the order in which the author learned them — culminating in advanced topics like functional domain modeling, and how to write and use monads. Some of the book’s lessons include: - A simple set of rules for functional programming in Scala - How and why to write pure functions and use immutable variables - Why function signatures in FP are *much* more important than method signatures in OOP - How pure functions work with I/O (file, database, and network) - How to read anonymous functions - Lessons on recursion, with many images to help explain how it works - How the concepts of JVM stacks and stack frames work - Partially-applied functions and currying - How using Option naturally leads to flatMap, and how flatMap naturally leads to for-comprehensions - How and why to use case classes and pattern matching - How to use monads like State and IO - How to use monad transformers like StateT - How (and why) to write your own monads - Domain modeling in functional programming - How to use “lenses” to update immutable data models - Concurrency lessons cover Akka actors and Scala futures - Visual lessons on collections’ methods like fold and reduce - How to use the ScalaCheck property-testing framework - How to write and use “type classes” - Algebraic Data Types (ADTs) are explained All told, the book contains 120 small chapters. Source code examples from the book are available as a series of Github repositories that you can download and work with.

    Easy-to-browse and ideal as a quick reference, this guide will help experienced C#, Java, and C++ programmers get up to speed with the latest version of the C# language. All programs and code snippets in this book are available as interactive samples in LINQPad. You can edit these samples and instantly see the results without needing to set up projects in Visual Studio. Written by the authors of C# 7.0 in a Nutshell, this pocket reference covers C# 7.0 without skimping on detail, including: All of C#’s fundamentals Features new to C# 7.0, including tuples, pattern matching, and deconstructors Advanced topics: operator overloading, type constraints, iterators, nullable types, operator lifting, lambda expressions, and closures LINQ: sequences, lazy execution, standard query operators, and query expressions Unsafe code and pointers, custom attributes, preprocessor directives, and XML documentation

    Designed for readers who don't need the academic formality, it's a fast and easy computer science guide. It teaches essential concepts for people who want to program computers effectively. First, it introduces discrete mathematics, then it exposes the most common algorithms and data structures. It also shows the principles that make computers and programming languages work.

    No previous functional programming experience required! This book walks you through the right concepts at the right pace, as you explore immutable values and explicit data transformation, functions, modules, recursive functions, pattern matching, high-order functions, polymorphism, and failure handling, all while avoiding side effects. Don't board the Elixir train with an imperative mindset! To get the most out of functional languages, you need to think functionally. This book will get you there.Functional programming offers useful techniques for building maintainable and scalable software that solves today's difficult problems. The demand for software written in this way is increasing - you don't want to miss out. In this book, you'll not only learn Elixir and its features, you'll also learn the mindset required to program functionally. Elixir's clean syntax is excellent for exploring the critical skills of using functions and concurrency.Start with the basic techniques of the functional way: working with immutable data, transforming data in discrete steps, and avoiding side effects. Next, take a deep look at values, expressions, functions, and modules. Then extend your programming with pattern matching and flow control with case, if, cond, and functions. Use recursive functions to create iterations. Work with data types such as lists, tuples, and maps. Improve code reusability and readability with Elixir's most common high-order functions. Explore how to use lazy computation with streams, design your data, and take advantage of polymorphism with protocols. Combine functions and handle failures in a maintainable way using Elixir features and libraries.Learn techniques that matter to make code that lives harmoniously with the language.What You Need: You'll need a computer and Elixir 1.4 or newer version installed. No previous functional programming or Elixir experience is required. Some experience with any programming language is recommended.

    

    We can either grow complacent, and go extinct like the dinosaurs, or spread throughout the cosmos, as Carl Sagan dreamed of. What if your toothbrush becomes smarter than you? What happens to your business, your country, your planet and yourself? What if your car doesn’t need a driver anymore? What if we don’t need to age and die? What if machines are smarter than us? What if, instead of fear of the future – you see opportunity, instead of an end – you see a beginning, instead of loss – you see profit, and instead of death – you see life? What if you and your organization get future-primed? For many years Nikola Danaylov has been interviewing the future and motivating people all over the world to embrace rather than fear it. "Conversations with the Future" was born from those interviews and Nik's unceasing need to explore "What If" with some of the most forward thinking visionaries in the world today.

    New progressive web apps have capabilities that will soon make you obsolete. With this hands-on guide, web developers and business execs will learn how—and why—to develop web apps that take advantage of features that have so far been exclusive to native apps. Features that include fast load times, push notifications, offline access, homescreen shortcuts, and an entirely app-like experience. By leveraging the latest browser APIs, progressive web apps combine all of the benefits of native apps, while avoiding their issues. Throughout the book, author Tal Ater shows you how to improve a simple website for the fictional Gotham Imperial Hotel into a modern progressive web app. Plus: Understand how service workers work, and use them to create sites that launch in an instant, regardless of the user’s internet connection Create full-screen web apps that launch from the phone's homescreen just like native apps Re-engage users with push notifications, even days after they have left your site Embrace offline-first and build web apps that gracefully handle loss of connectivity Explore new UX opportunities and challenges presented by progressive web apps

    Powerful Python is different. Written for experienced developers like you, its carefully crafted chapters teach intermediate and advanced strategies, patterns, and tools for modern Python. Focused on Python 3, with full support for 2.7. DRM-free digital upgrade: powerfulpython.com/book-upgrade "Feels like Neo learning Jiu jitsu in the Matrix." - John Beauford (@johnbeauford) "I just wanted to let you know what an excellent book this is... I keep going back to your book to learn Python." - Fahad Qazi, London, UK "Thanks. Keep up the good work. Your chapter on decorators is the best I have seen on that topic." - Leon Tietz, Minnesota, USA "Powerful Python is already helping me get huge optimization gains." - Timothy Dobbins (@TmthyDobbins) "What have I found good and valuable about the book so far? Everything honestly. The clear explanations, solid code examples have really helped me advance as a Python coder... Thank you! It has really helped me grasp some advanced concepts that I felt were beyond my abilities." - Nick S., Colorado, USA For data scientists, back-end engineers, web developers, sysadmins, devops, QA testers and more. What's included: An unrelenting selective spotlight on what's most valuable and impactful to working, full-time, professional Python developers Well-researched, detailed, realistic code on almost every page, powerfully illustrating key points. Very little "toy code" How to use decorators to add rich features to functions and classes; untangle distinct, frustratingly intertwined concerns in your code; and build powerful, extensible software frameworks How to use Python in ways that incentivize other developers to use and re-use your code, again and again... amplifying the impact of the code you write, and boosting your reputation among your peers Powerfully and easily weave iterators and generators throughout your applications, making them massively scalable, highly performant, and far more readable and maintainable How to fully leverage Python's exception and error model... giving you a detailed understanding even experienced Pythonistas often lack, and putting some of the most powerfully Pythonic exception-handling patterns in your toolbox How "magic methods" imbue natural, readable, expressive syntax into your classes and objects... and how to "break the rules" to craft stunningly intuitive, compellingly reusable library interfaces Valuable and powerful design patterns, and how Python's special language features give you uniquely powerful implementation

    This report discusses strategies and techniques for building scalable and resilient microservices, and helps you work your way through the evolution of a scalable microservices-based system.When it comes to development speed, time-to-market, and continuous delivery, microservices can do wonders for your organization. Author Jonas Bonér, Founder and CTO of Lightbend and author of Reactive Microservices Architecture (O’Reilly), demonstrates how to refactor a monolithic application step-by-step. You’ll briefly land at single instance microliths (micro monoliths) before working your way toward a scalable and resilient microsystem.This report will help you:- Examine the essential traits of an individual reactive microservice- Understand why monolithic architectures are a problem- Manage the hard part of microservice design: the space between individual services- Shift the focus from domain objects to events in domain-driven design- Make services more efficient, performant, and stable by applying reactive programming techniques- Make the services work together, collaboratively, as a single reactive system- Move beyond CRUD towards Event Sourcing/CQRS to scale state in an event-based design- Leverage fast data in microservices to manage real-time data at scale

    About This Book - Taking a practical approach to studying Python - A clear appreciation of the sequence-oriented parts of Python - Emphasis on the way in which Python code is structured - Learn how to produce bug-free code by using testing tools Who This Book Is For The Python Apprentice is for anyone who wants to start building, creating and contributing towards a Python project. No previous knowledge of Python is required, although at least some familiarity with programming in another language is helpful. What You Will Learn - Learn the language of Python itself - Get a start on the Python standard library - Learn how to integrate 3rd party libraries - Develop libraries on your own - Become familiar with the basics of Python testing In Detail Experienced programmers want to know how to enhance their craft and we want to help them start as apprentices with Python. We know that before mastering Python you need to learn the culture and the tools to become a productive member of any Python project. Our goal with this book is to give you a practical and thorough introduction to Python programming, providing you with the insight and technical craftsmanship you need to be a productive member of any Python project. Python is a big language, and it's not our intention with this book to cover everything there is to know. We just want to make sure that you, as the developer, know the tools, basic idioms and of course the ins and outs of the language, the standard library and other modules to be able to jump into most projects. Style and approach We introduce topics gently and then revisit them on multiple occasions to add the depth required to support your progression as a Python developer. We've worked hard to structure the syllabus to avoid forward references. On only a few occasions do we require you to accept techniques on trust, before explaining them later; where we do, it's to deliberately establish good habits.

    You'll learn techniques that speed the delivery of your site's assets to the user, increase rendering speed, decrease the overall footprint of your site, as well as how to build a workflow that automates common optimization techniques.Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.About the TechnologyNifty features, hip design, and clever marketing are great, but your website will flop if visitors think it's slow. Network conditions can be unpredictable, and with today's sites being bigger than ever, you need to set yourself apart from the competition by focusing on speed. Achieving a high level of performance is a combination of front-end architecture choices, best practices, and some clever sleight-of-hand. This book will demystify all these topics for you.About the BookWeb Performance in Action is your guide to making fast websites. Packed with "Aha!" moments and critical details, this book teaches you how to create performant websites the right way. You'll master optimal rendering techniques, tips for decreasing your site's footprint, and technologies like HTTP/2 that take your website's speed from merely adequate to seriously fast. Along the way, you'll learn how to create an automated workflow to accomplish common optimization tasks and speed up development in the process.What's InsideFoolproof performance-boosting techniquesOptimizing images and fontsHTTP/2 and how it affects your optimization workflowAbout the ReaderThis book assumes that you're familiar with HTML, CSS, and JavaScript. Many examples make use of Git and Node.js.About the AuthorJeremy Wagner is a professional front-end web developer with over ten years of experience. Foreword by Ethan Marcotte.Table of ContentsUnderstanding web performanceUsing assessment toolsOptimizing CSSUnderstanding critical CSSMaking images responsiveGoing further with imagesFaster fontsKeeping JavaScript lean and fastBoosting performance with service workersFine-tuning asset deliveryLooking to the future with HTTP/2Automating optimization with gulp

    Learning to use functional programming is a good way to write more concise code, with greater concurrency and performance. The JavaScript language is particularly suited to functional programming.This book provides comprehensive coverage of the major topics in functional programming with JavaScript to produce shorter, clearer, and testable programs.You'll delve into functional programming; including writing and testing pure functions, reducing side-effects, and other features to make your applications functional in nature.Specifically, we'll explore techniques to simplify coding, apply recursion for loopless coding, learn ways to achieve immutability, implement design patterns, and work with data types.By the end of this book, you'll have developed the JavaScript skills you need to program functional applications with confidence. What you will learn Create more reliable code with closures and immutable data Convert existing methods into pure functions, and loops into recursive methods Develop more powerful applications with currying and function composition Separate the logic of your system from implementation details Implement composition and chaining techniques to simplify coding Use functional programming techniques where it makes the most sense Table of Contents Becoming Functional - Several Questions Thinking Functionally - A First Example Starting Out with Functions - A Core Concept Behaving Properly - Pure Functions Programming Declaratively - A Better Style Producing Functions - Higher-Order Functions Transforming Functions - Currying and Partial Application Connecting Functions - Pipelining and Composition Designing Functions - Recursion Ensuring Purity - Immutability Implementing Design Patterns - The Functional Way Building Better Containers - Functional Data Types

    As John invested in these skills his career took off, and he became a highly paid, highly sought-after developer and consultant. Today John helps more than 1.4 million programmers every year to increase their income by developing this unique blend of skills. "If you're a developer, green or a veteran, you owe it to yourself to read The Complete Software Developers Career Guide." - Jason Down, Platform Developer, Ontario, Canada What You Will Learn in This Book How to systematically find and fill the gaps in your technical knowledge so you can face any new challenge with confidence Should you take contract work - or hold out for a salaried position? Which will earn you more, what the tradeoffs are, and how your personality should sway your choice Should you learn JavaScript, C#, Python, C++? How to decide which programming language you should master first Ever notice how every job ever posted requires "3-5 years of experience," which you don't have? Simple solution for this frustrating chicken-and-egg problem that allows you to build legitimate job experience while you learn to code Is earning a computer science degree a necessity - or a total waste of time? How to get a college degree with maximum credibility and minimum debt Coding bootcampssome are great, some are complete scams. How to tell the difference so you don't find yourself cheated out of $10,000 Interviewer tells you, "Dress code is casual around here - the development team wears flipflops." What should you wear? How do you deal with a boss who's a micromanager. Plus how helping your manager with his goals can make you the MVP of your team The technical skills that every professional developer must have - but no one teaches you (most developers are missing some critical pieces, they don't teach this stuff in college, you're expected to just "know" this) An inside look at the recruiting industry. What that "friendly" recruiter really wants from you, how they get paid, and how to avoid getting pigeonholed into a job you'll hate Who Should Read This Book Entry-Level Developers This book will show you how to ensure you have the technical skills your future boss is looking for, create a resume that leaps off a hiring manager's desk, and escape the "no work experience" trap. Mid-Career Developers You'll see how to find and fill in gaps in your technical knowledge, position yourself as the one team member your boss can't live without, and turn those dreaded annual reviews into chance to make an iron-clad case for your salary bump. Senior Developers This book will show you how to become a specialist who can command above-market wages, how building a name for yourself can make opportunities come to you, and how to decide whether consulting or entrepreneurship are paths you should pursue.

    It is also for Linux developers and system programmers who are familiar with embedded systems and want to learn and program the best in class devices. It is appropriate for students studying embedded techniques, for developers implementing embedded Linux devices, and engineers supporting existing Linux devices. What You Will Learn - Evaluate the Board Support Packages offered by most manufacturers of a system on chip or embedded module - Use Buildroot and the Yocto Project to create embedded Linux systems quickly and efficiently - Update IoT devices in the field without compromising security - Reduce the power budget of devices to make batteries last longer - Interact with the hardware without having to write kernel device drivers - Debug devices remotely using GDB, and see how to measure the performance of the systems using powerful tools such as perk, ftrace, and valgrind - Find out how to configure Linux as a real-time operating system In Detail Embedded Linux runs many of the devices we use every day, from smart TVs to WiFi routers, test equipment to industrial controllers - all of them have Linux at their heart. Linux is a core technology in the implementation of the inter-connected world of the Internet of Things. The comprehensive guide shows you the technologies and techniques required to build Linux into embedded systems. You will begin by learning about the fundamental elements that underpin all embedded Linux projects: the toolchain, the bootloader, the kernel, and the root filesystem. You'll see how to create each of these elements from scratch, and how to automate the process using Buildroot and the Yocto Project. Moving on, you'll find out how to implement an effective storage strategy for flash memory chips, and how to install updates to the device remotely once it is deployed. You'll also get to know the key aspects of writing code for embedded Linux, such as how to access hardware from applications, the implications of writing multi-threaded code, and techniques to manage memory in an efficient way. The final chapters show you how to debug your code, both in applications and in the Linux kernel, and how to profile the system so that you can look out for performance bottlenecks. By the end of the book, you will have a complete overview of the steps required to create a successful embedded Linux system. Style and approach This book is an easy-to-follow and pragmatic guide with in-depth analysis of the implementation of embedded devices. It follows the life cycle of a project from inception through to completion, at each stage giving both the theory that underlies the topic and practical step-by-step walkthroughs of an example implementation.

    Others may be checking out reactive programming just to see what it is all about, and to judge whether it can solve any problems they may have. What You Will Learn Learn the features of RxJava 2 that bring about many significant changes, including new reactive types such as Flowable, Single, Maybe, and Completable Understand how reactive programming works and the mindset to "think reactively" Demystify the Observable and how it quickly expresses data and events as sequences Learn the various Rx operators that transform, filter, and combine data and event sequences Leverage multicasting to push data to multiple destinations, and cache and replay them Discover how concurrency and parallelization work in RxJava, and how it makes these traditionally complex tasks trivial to implement Apply RxJava and Retrolambda to the Android domain to create responsive Android apps with better user experiences Use RxJava with the Kotlin language to express RxJava more idiomatically with extension functions, data classes, and other Kotlin features In Detail RxJava is a library for composing asynchronous and event-based programs using Observable sequences for the JVM, allowing developers to build robust applications in less time.Learning RxJava addresses all the fundamentals of reactive programming to help readers write reactive code, as well as teach them an effective approach to designing and implementing reactive libraries and applications.Starting with a brief introduction to reactive programming concepts, there is an overview of Observables and Observers, the core components of RxJava, and how to combine different streams of data and events together. You will also learn simpler ways to achieve concurrency and remain highly performant, with no need for synchronization. Later on, we will leverage backpressure and other strategies to cope with rapidly-producing sources to prevent bottlenecks in your application. After covering custom operators, testing, and debugging, the book dives into hands-on examples using RxJava on Android as well as Kotlin. Style and approach This book will be different from other Rx books, taking an approach that comprehensively covers Rx concepts and practical applications.

    Overland's Python Without Fear reveals the "whys," "tricks," and especially the "gotchas" behind each essential Python language feature. You'll learn how to use Python the right way, avoiding mistakes that trip up programmers coming from other languages -- and avoiding hours of unnecessary debugging, too. Best of all, you'll enjoy learning Python. That's because Overland teaches Python by showing how to leverage its power to solve fascinating, challenging puzzles and games. Along the way, you'll learn how to use mutable and immutable objects; work with strings, functions, local and global variables, lists, data, inheritance, properties, files, exceptions, enumerators, generators, iterators, and even multi-file apps. Throughout, you'll never get bogged down in unnecessarily complex examples or pointless discussions: Overland keeps you 100% focused on learning what works -- and what matters.

    Numerous brain cycles were spent to make it:* Beginner-friendly yet comprehensive. From the very basics of programming up to full-stack web development, a lot of topics are covered in a simple and accessible way. No prior knowledge needed!* Standards-aligned. This book is entirely written using the recent ES2015 syntax, giving you future-proof knowledge. From start to finish, it enforces good programming habits, embraces the ubiquitous JavaScript tools ESLint and Prettier and closely follows the popular AirBnb Style Guide.* Hands-on. No real learning happens without practicing! Each chapter is accompanied by a series of exercises to put your newly acquired skills into action. A three-part project will guide you in the creation of a social news web application (see it in action).* Easy to follow. Code along directly in your browser or build yourself a great JavaScript development environment.

    Now in its 8th edition, you’ll find all the very latest C# 7.1 and .NET 4.7 features here, along with four brand new chapters on Microsoft’s lightweight, cross-platform framework, .NET Core, up to and including .NET Core 2.0. Coverage of ASP.NET Core, Entity Framework (EF) Core, and more, sits alongside the latest updates to .NET, including Windows Presentation Foundation (WPF), Windows Communication Foundation (WCF), and ASP.NET MVC. Dive in and discover why Pro C# has been a favorite of C# developers worldwide for over 15 years. Gain a solid foundation in object-oriented development techniques, attributes and reflection, generics and collections as well as numerous advanced topics not found in other texts (such as CIL opcodes and emitting dynamic assemblies). With the help of this book you’ll have the confidence to put C# into practice and explore the .NET universe on your own terms. What You Will Learn Discover the latest C# 7.1 features, from tuples to pattern matching Hit the ground running with Microsoft’s lightweight, open source .NET Core platform, including ASP.NET Core MVC, ASP.NET Core web services, and Entity Framework Core Find complete coverage of XAML, .NET 4.7, and Visual Studio 2017 Understand the philosophy behind .NET and the new, cross-platform alternative, .NET Core

    SEVEN STEP UX is a business-savvy, hands-on process for devising a great product idea, including planning, applying UX research, creating the design and testing. In this book, we will: - Understand the basics of UX and see how it is essential for business - Learn how to plan a product (let it be a website or app). - How to apply UX research to validate your ideas and create better products (all methods are hands-on and step-by step) - How to start sketching your ideas and building up meaningful wireframes - How to flesh out wireframes and create an interactive prototype that you can test with target users - How to create a kick-ass visual design for your product that is engaging to your target audience - How to test out designs, mobile apps, landing pages to increase conversions and improve usability - How to hand-off designs for developers that they'll love. This book will guide you through all the steps, in a lightweight, conversational way with humor. Also, if you buy this book, you will have access to the exclusive 7STEPUX APP. In the App you can: - Download practical templates, checklists and templates to boost UX work - Ask questions to the author and discuss UX with other people who've already purchased the book - Access multiple formats of the book for a better reading experience

    The book is easy to follow and is written for interview preparation point of view. In various books, the examples are solved in various languages like Go, C, C++, Java, C#, Python, VB, JavaScript and PHP. GitHub Repositories https://github.com/Hemant-Jain-Author Book’s Composition This book is designed for interviews so in Chapter 0, various preparation plans are proposed. Then in chapters 1, a brief introduction of the programming language and concept of recursion is explained. A number of problems based on recursion and array are explained. Then in the coming chapter, we will be looking into complexity analysis. Then we will be looking into Sorting & Searching techniques. Then will look into the various data structures and their algorithms. We will be looking into a Linked List, Stack, Queue, Trees, Heap, Hash Table and Graphs. Then we will be looking into algorithm analysis, we will be looking into Brute Force algorithms, Greedy algorithms, Divide & Conquer algorithms, Dynamic Programming, and Backtracking. In the end, we will be looking into System Design, which will give a systematic approach for solving the design problems in an Interview. Table of Contents Chapter 0: How to use this book. Chapter 1: Introduction - Programming Overview Chapter 2: Algorithms Analysis Chapter 3: Approach to solve algorithm design problems Chapter 4: Abstract Data Type Chapter 5: Searching Chapter 6: Sorting Chapter 7: Linked List Chapter 8: Stack Chapter 9: Queue Chapter 10: Tree Chapter 11: Priority Queue Chapter 12: Hash-Table Chapter 13: Graphs Chapter 14: String Algorithms Chapter 15: Algorithm Design Techniques Chapter 16: Brute Force Algorithm Chapter 17: Greedy Algorithm Chapter 18: Divide & Conquer Chapter 19: Dynamic Programming Chapter 20: Backtracking Chapter 21: Complexity Theory Chapter 22: Interview Strategy Chapter 23: System Design

    Vol.I covers topics such as GDD and Communications.The idea behind this book is to summarize the body of knowledge that already exists on multiplayer games but is not available in one single place. And quite a few of the issues discussed within this series, while known in the industry, have not been published at all (except for maybe in discussion forums). Programming and deploying an MOG is a daunting task, and having a frame of reference is usually quite helpful — "hey, those guys have already tried this, and it worked for them."

    

    From spacing, bracing, and semicolons to proper API style, discover the whys behind each recommendation, and add to or establish your own house style guidelines. This practical, powerful, and opinionated guide offers the best practices you need to know to work successfully in this equally opinionated programming language.Apple's Swift programming language has finally reached stability, and developers are demanding to know how to program the language properly. Swift Style guides you through the ins and outs of Swift programming best practices. This is the first best practices book for serious, professional Swift programmers and for programmers who want to shine their skills to be hired in this demanding market.A style guide offers a consistent experience of well-crafted code that lets you focus on the code's underlying meaning, intent, and implementation. This book doesn't offer canonical answers on Swift coding style. It explores the areas of Swift where structure comes into play. Whether you're developing a personal style or a house style, there are always ways to enhance your code choices. You'll find here the ideas and principles to establish or enhance your own best style practices.Begin with simple syntactical styling. Strengthen code bracing for easy readability. Style your closures for safety and resilience. Perfect spacing and layout. Master literal initialization and typing. Optimize control flow layout and improve conditional style choices. Transition from Objective-C and move code into Swift the right way. Boost API design using proper naming and labeling. Elevate defaulted arguments and variadics to their right places. Finally, Erica offers her own broad recommendations on good coding practice.What You Need: Recent version of the Swift programming language

    If you want a well formatted ebook with those examples, this is the book. If you only want an online version, don't buy this. Go to the github version under the mattharrison account. The content is available for free there. If you prefer a physical copy that has extra space to jot notes for your next project, consider purchasing the paperback version. Warning, this is not an introduction to Python. Rather it is a notebook containing curated examples for Python 3 as well as the new features found in Python 3.6. It is designed to accompany technical training or aid those who want a quick refresher to the Python syntax. It provides examples for: REPL Types Unicode String Formatting Functions Classes Looping Exceptions Decorators Class Decorators Metaclasses Generators Coroutines Comprehensions Context Managers Type Annotations and more Matt Harrison has many years of Python experience across the domains of search, build management and testing, business intelligence, data science, machine learning, and storage. He currently runs MetaSnake, a Python training and consultancy shop.

    Just because this is a relatively new field of study, it should not be scary to learn or thought to be too difficult to understand. Anyone who has ever turned on a phone or surfed the Internet should have a basic understanding of what happens when the mouse is clicked or the screen is touched (and how fast it happens!). How does a simple process convert to 1’s and 0’s and travel thousands of miles in a blink of the eye? What is an IP address? What do IP/TCP, DNS, HTML, and CSS stand for? How do large movies and thousands of songs all fit onto a hard drive? How can secrets be sent in plain sight? These questions are answered in Computer Science Principles: The Foundational Concepts of Computer Science, plus spreadsheets, photo-editing, web-design (HTML and CSS), learning to code with JavaScript, and more!

    Enrich your microservices with continous integration and monitoring. Containerize your application with Docker Deploy your application to AWS. Learn how to utilize the powerful AWS services from within your application Book Description Cloud computing and microservices are two very important concepts in modern software architecture. They represent key skills that ambitious software engineers need to acquire in order to design and build software applications capable of performing and scaling. Go is a modern cross-platform programming language that is very powerful yet simple; it is an excellent choice for microservices and cloud applications. Go is gaining more and more popularity, and becoming a very attractive skill..The book will take you on a journey into the world of microservices and cloud computing with the help of Go. It will start by covering the software architectural patterns of cloud applications, as well as practical concepts regarding how to scale, distribute, and deploy those applications. You will also learn how to build a JavaScript-based front-end for your application, using TypeScript and React.From there, we dive into commercial cloud offerings by covering AWS. Finally, we conclude our book by providing some overviews of other concepts and technologies that the reader can explore to move from where the book leaves off. What you will learn Understand modern software applications architectures Build secure microservices that can effectively communicate with other services Get to know about event-driven architectures by diving into message queues such as Kafka, Rabbitmq, and AWS SQS. Understand key modern database technologies such as MongoDB, and Amazon's DynamoDB Leverage the power of containers Explore Amazon cloud services fundamentals Know how to utilize the power of the Go language to access key services in the Amazon cloud such as S3, SQS, DynamoDB and more. Build front-end applications using ReactJS with Go Implement CD for modern applications Table of Contents Modern Microservice Architectures Building Microservices using Rest APIs Securing Microservices Asynchronous Microservice Architectures Using Message Queues Building a Frontend with React Deploying Your Application in Containers AWS AWS- II Continuous Delivery Monitoring Migration Where to go from here

    NW.js radically simplifies desktop development, providing a true cross-platform development stack built on HTML, CSS and JavaScript, Node.js modules, and the Chrome Blink engine. NW.js applications interact with the host operating system just like any other platform-native project, so developers have full access to all local files and resources. The performance is great, and best of all, it saves developers time because they only have to write one version of their application.Cross-Platform Desktop Applications guides readers step-by-step as they learn to develop NW.js desktop applications that run on Windows, OSX and Linux. They begin by getting the big picture of what NW.js can (and can't) do. Readers test drive NW.js as they build their first desktop application. Next, they find out how to take advantage of OS- specific features like menus, system-tray apps, clipboards, and the file system. Along the way, this book teaches how to debug errors and diagnose performance bottlenecks with NW.j's browser developer tools, package an application as a standalone executable for each OS, and even distribute it to various app stores. The book gives developers the inspiration and skills they need to code pro quality desktop applications using the web languages they already know.Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

    Many old Java idioms are no longer needed and new features such as modularization make you far more effective. However, navigating these changes can be challenging.   Core Java® SE 9 for the Impatient, Second Edition, is a complete yet concise guide that includes all the latest changes up to Java SE 9. Written by Cay S. Horstmann–author of the classic two-volume Core Java–this indispensable tutorial offers a faster, easier pathway for learning modern Java. Given Java SE 9’s size and the scope of its enhancements, there’s plenty to cover, but it’s presented in small chunks organized for quick access and easy understanding.   Horstmann’s practical insights and sample code help you quickly take advantage of all that’s new, from Java SE 9’s long-awaited “Project Jigsaw” module system to the improvements first introduced in Java SE 8, including lambda expressions and streams. Use modules to simplify the development of well-performing complex systems Migrate applications to work with the modularized Java API and third-party modules Test code as you create it with the new JShell Read-Eval-Print Loop (REPL) Use lambda expressions to express actions more concisely Streamline and optimize data management with today’s Streams API Leverage modern concurrent programming based on cooperating tasks Take advantage of a multitude of API improvements for working with collections, input/output, regular expressions, and processes Whether you’re just getting started with modern Java or you’re an experienced developer, this guide will help you write tomorrow’s most robust, efficient, and secure Java code. Register your product at informit.com/register for convenient access to downloads, updates, and/or corrections as they become available.

    The pytest testing framework helps you write tests quickly and keep them readable and maintainable - with no boilerplate code. Using a robust yet simple fixture model, it's just as easy to write small tests with pytest as it is to scale up to complex functional testing for applications, packages, and libraries. This book shows you how.For Python-based projects, pytest is the undeniable choice to test your code if you're looking for a full-featured, API-independent, flexible, and extensible testing framework. With a full-bodied fixture model that is unmatched in any other tool, the pytest framework gives you powerful features such as assert rewriting and plug-in capability - with no boilerplate code.With simple step-by-step instructions and sample code, this book gets you up to speed quickly on this easy-to-learn and robust tool. Write short, maintainable tests that elegantly express what you're testing. Add powerful testing features and still speed up test times by distributing tests across multiple processors and running tests in parallel. Use the built-in assert statements to reduce false test failures by separating setup and test failures. Test error conditions and corner cases with expected exception testing, and use one test to run many test cases with parameterized testing. Extend pytest with plugins, connect it to continuous integration systems, and use it in tandem with tox, mock, coverage, unittest, and doctest.Write simple, maintainable tests that elegantly express what you're testing and why.What You Need: The examples in this book are written using Python 3.6 and pytest 3.0. However, pytest 3.0 supports Python 2.6, 2.7, and Python 3.3-3.6.

    You'll use Rails 5.1, Minitest 5, and RSpec 3.6, as well as popular testing libraries such as factory_girl and Cucumber. Updates include Rails 5.1 system tests and Webpack integration. Do what the doctor ordered to make your applications feel all better. Side effects may include better code, fewer bugs, and happier developers.Your Ruby on Rails application is sick. Deadlines are looming, but every time you make the slightest change to the code, something else breaks. Nobody remembers what that tricky piece of code was supposed to do, and nobody can tell what it actually does. Plus, it has bugs. You need test-driven development: a process for improving the design, maintainability, and long-term viability of software.With both practical code examples and discussion of why testing works, this book starts with the most basic features delivered as part of core Ruby on Rails. Once you've integrated those features into your coding practice, work with popular third-party testing tools such as RSpec, Jasmine, Cucumber, and factory_girl. Test the component parts of a Rails application, including the back-end model logic and the front-end display logic. With Rails examples, use testing to enable your code to respond better to future change. Plus, see how to handle real-world testing situations.This new edition has been updated to Rails 5.1 and RSpec 3.6 and contains full coverage of new Rails features, including system tests and the Webpack-based JavaScript setup.What You Need: Ruby 2.4, Rails 5.1

    Reduce the development time for your applications. - Understand the scope and power of STL features to deal with real-world problems. - Compose your own algorithms without forfeiting the simplicity and elegance of the STL way. Who This Book Is For This book is for intermediate-to-advanced C++ programmers who want to get the most out of the Standard Template Library of the newest version of C++: C++ 17. What You Will Learn - Learn about the new core language features and the problems they were intended to solve - Understand the inner workings and requirements of iterators by implementing them - Explore algorithms, functional programming style, and lambda expressions - Leverage the rich, portable, fast, and well-tested set of well-designed algorithms provided in the STL - Work with strings the STL way instead of handcrafting C-style code - Understand standard support classes for concurrency and synchronization, and how to put them to work - Use the filesystem library addition available with the C++17 STL In Detail C++ has come a long way and is in use in every area of the industry. Fast, efficient, and flexible, it is used to solve many problems. The upcoming version of C++ will see programmers change the way they code. If you want to grasp the practical usefulness of the C++17 STL in order to write smarter, fully portable code, then this book is for you. Beginning with new language features, this book will help you understand the language's mechanics and library features, and offers insight into how they work. Unlike other books, ours takes an implementation-specific, problem-solution approach that will help you quickly overcome hurdles. You will learn the core STL concepts, such as containers, algorithms, utility classes, lambda expressions, iterators, and more, while working on practical real-world recipes. These recipes will help you get the most from the STL and show you how to program in a better way. By the end of the book, you will be up to date with the latest C++17 features and save time and effort while solving tasks elegantly using the STL. Style and approach This recipe-based guide will show you how to make the best use of C++ together with the STL to squeeze more out of the standard language

    This practical guide delivers the knowledge you need to roll up your sleeves and create exceptional embedded projects with this lean and efficient programming language. If you’re familiar with Python as a programmer, educator, or maker, you’re ready to learn—and have fun along the way. Author Nicholas Tollervey takes you on a journey from first steps to advanced projects. You’ll explore the types of devices that run MicroPython, and examine how the language uses and interacts with hardware to process input, connect to the outside world, communicate wirelessly, make sounds and music, and drive robotics projects. Work with MicroPython on four typical devices: PyBoard, the micro:bit, Adafruit’s Circuit Playground Express, and ESP8266/ESP32 boards Explore a framework that helps you generate, evaluate, and evolve embedded projects that solve real problems Dive into practical MicroPython examples: visual feedback, input and sensing, GPIO, networking, sound and music, and robotics Learn how idiomatic MicroPython helps you express a lot with the minimum of resources Take the next step by getting involved with the Python community

    Having automated unit testing in place helps developers to achieve these goals. The JUnit testing framework is a popular choice among Java developers and has recently released a major version update with JUnit 5.This book shows you how to make use of the power of JUnit 5 to write better software.The book begins with an introduction to software quality and software testing. After that, you will see an in-depth analysis of all the features of Jupiter, the new programming and extension model provided by JUnit 5. You will learn how to integrate JUnit 5 with other frameworks such as Mockito, Spring, Selenium, Cucumber, and Docker.After the technical features of JUnit 5, the final part of this book will train you for the daily work of a software tester. You will learn best practices for writing meaningful tests. Finally, you will learn how software testing fits into the overall software development process, and sits alongside continuous integration, defect tracking, and test reporting. What you will learn The importance of software testing and its impact on software quality The options available for testing Java applications The architecture, features and extension model of JUnit 5 Writing test cases using the Jupiter programming model How to use the latest and advanced features of JUnit 5 Integrating JUnit 5 with existing third-party frameworks Best practices for writing meaningful JUnit 5 test cases Managing software testing activities in a living software project About the Author Boni Garcia has a PhD degree on Information and Communications Technology from Technical University of Madrid (UPM) in Spain since 2011. Currently he works as a Researcher at King Juan Carlos University (URJC) and Assistant Professor at Digital Art and Technology University (U-tad) in Spain. He is member of Kurento project, where he is in charge of the testing framework for WebRTC applications. He participates in the coordination of the ElasTest project, an elastic platform aimed to ease end-to-end testing. Boni is an active member on the free open source software (FOSS) community with big emphasis on software testing and web engineering. Among other, he owns the open source projects WebDriverManager and selenium-jupiter (JUnit 5 extension for Selenium). Table of Contents Retrospective on software quality and Java testing What's new in JUnit 5 JUnit 5 standard tests Simplifying testing with advanced JUnit features Integration of JUnit 5 with external frameworks From requirements to test cases Testing management

    This textbook provides a comprehensive treatment of the theoretical and practical aspects of discovering, analyzing, modeling, validating, testing, and writing requirements for systems of all kinds, with an intentional focus on software-intensive systems. It brings into play a variety of formal methods, social models, and modern requirements for writing techniques to be useful to the practicing engineer.This book was written to support both undergraduate and graduate requirements engineering courses. Each chapter includes simple, intermediate, and advanced exercises. Advanced exercises are suitable as a research assignment or independent study and are denoted by an asterisk. Various exemplar systems illustrate points throughout the book, and four systems in particular--a baggage handling system, a point of sale system, a smart home system, and a wet well pumping system--are used repeatedly. These systems involve application domains with which most readers are likely to be familiar, and they cover a wide range of applications from embedded to organic in both industrial and consumer implementations. Vignettes at the end of each chapter provide mini-case studies showing how the learning in the chapter can be employed in real systems.Requirements engineering is a dynamic field and this text keeps pace with these changes. Since the first edition of this text, there have been many changes and improvements. Feedback from instructors, students, and corporate users of the text was used to correct, expand, and improve the material. This third edition includes many new topics, expanded discussions, additional exercises, and more examples. A focus on safety critical systems, where appropriate in examples and exercises, has also been introduced. Discussions have also been added to address the important domain of the Internet of Things. Another significant change involved the transition from the retired IEEE Standard 830, which was referenced throughout previous editions of the text, to its successor, the ISO/IEC/IEEE 29148 standard.

    In particular, this book is especially useful for front-end developers who want to use their current skillset to build mobile applications. An existing working knowledge of JavaScript will help you get the most out of this book. What You Will Learn - Implement native React Native components and APIs - Explore React's JSX syntax - Manage data using Redux and Redux middleware - Build applications with React Native on both iOS and Android platforms - Perform animations in your applications using the animation APIs - Understand routing and Navigator comparison - Create your own Native module In Detail React Native has completely revolutionized mobile development by empowering JavaScript developers to build world-class mobile apps that run natively on mobile platforms. This book will show you how to apply JavaScript and other front-end skills to build cross-platform React Native applications for iOS and Android using a single codebase. This book will provide you with all the React Native building blocks necessary to become an expert. We'll give you a brief explanation of the numerous native components and APIs that come bundled with React Native including Images, Views, ListViews, WebViews, and much more. You will learn to utilize form inputs in React Native. You'll get an overview of Facebook's Flux data architecture and then apply Redux to manage data with a remote API. You will also learn to animate different parts of your application, as well as routing using React Native's navigation APIs. By the end of the book, you will be able to build cutting-edge applications using the React Native framework. Style and approach This comprehensive guide will take your React Native skills to the next level. It shows you how to develop a clear workflow to build scalable applications, and how to implement the architectural concepts covered to build applications that shine in the real world.

    

    The use of procedural generation in game design can help with the intricate and multifarious aspects of game development; thus facilitating cost reduction. This form of development enables games to create their play areas, objects and stories based on a set of rules, rather than relying on the developer to handcraft each element individually. Readers will learn to create randomized maps, weave accidental plotlines, and manage complex systems that are prone to unpredictable behavior. Tanya Short’s and Tarn Adams’ Procedural Generation in Game Design offers a wide collection of chapters from various experts that cover the implementation and enactment of procedural generation in games. Designers from a variety of studios provide concrete examples from their games to illustrate the many facets of this emerging sub-discipline. Key Features: Introduces the differences between static/traditional game design and procedural game design Demonstrates how to solve or avoid common problems with procedural game design in a variety of concrete ways Includes industry leaders’ experiences and lessons from award-winning games World’s finest guide for how to begin thinking about procedural design

    To be a truly effective Ruby programmer, it’s not enough just to understand these features—you need to know how to use them in practice. Discover how to write code that is elegant, expressive, and a joy to use, and gain a deep understanding of these concepts so you can work with third-party gems and libraries more easily. Whether you are an intermediate or a seasoned Rubyist, you’ll find good use for these concepts in your code.

    - Build an Angular 2 application from scratch using TypeScript and the Angular command line interface. - Write code using the paradigm of reactive programming with RxJS and Observables. - Know how to Unit Test Angular 2 using Jasmine, Karma and the Angular Test Bed The first chapter in the course is a quickstart where you dive straight into writing your first Angular 2 application. We use the web editor plunker so you can get stuck in writing code ASAP. In this quickstart you'll get a 50,000 foot view of the major features of Angular 2. Then chapter by chapter we go much deeper into each of these features. I'll cover the theory for that feature, using plunker as much as possible so you can try out the code yourself in a browser. Then you'll practice what you've learnt with either an online quiz or a set of flash cards. You are going to learn all about:- - Typescript & ES6 Javascript. - Components & Binding - Directives - Dependancy Injection & Services - Angular Modules & Bootstrapping your Angular application. - SPAs & Routing - Angular CLI - Forms - Reactive Programming with RXJs - HTTP - Unit Testing The ideal student is an existing web developer, with some JavaScript knowledge that wants to add Angular 2 to their skill set. Or perhaps you are an existing Angular 1 developer who wants to level up to Angular 2. You do need to be comfortable with at least the ES5 version of JavaScript. We'll be using a UI framework called twitter bootstrap throughout the course but you still must know HTML and some CSS.

    About This Book - Expand your DevOps Toolkit with the DevOps thought leader, Viktor Farcic - Build, test, deploy, and monitor services inside Docker Swarm clusters - Translate your understanding to different hosting providers like AWS, Azure, and DigitalOcean - Go beyond simple deployment to explore how to create a continuous deployment process - Extend the deep understanding you gained from Viktor's DevOps 2.0 Toolkit book Who This Book Is For This book is for professionals interested in the full microservices life cycle combined with continuous deployment and containers. Target audience could be architects who want to know how to design their systems around microservices. It could be DevOps wanting to know how to apply modern configuration management practices and continuously deploy applications packed in containers. It is for developers who would like to take the process back into their hands as well as for managers who would like to gain a better understanding of the process used to deliver software from the beginning to the end. This book is for everyone wanting to know more about the software development life cycle starting from requirements and design, through the development and testing all the way until deployment and post-deployment phases. We'll create the processes taking into account the best practices developed by and for some of the biggest companies. What You Will Learn - Learn all aspects of Docker Swarm from building, testing, deploying, and monitoring services inside Docker Swarm clusters, available since Docker 1.12. - Master the deeper logic of DevOps with Viktor, so that you can successfully apply that logic across any specific set of tools you're working with. - Translate a deep understanding to different hosting providers like AWS, Azure, DigitalOcean, among others. - You'll go beyond simple deployment: you will explore with Viktor how to create a continuous deployment process. Accomplish zero-downtime deployments, and what to do in case of a failover. - Know how to run services at scale, how to monitor the systems, and how to make it heal itself. In Detail Viktor Farcic's latest book, The DevOps 2.1 Toolkit: Docker Swarm, takes you deeper into one of the major subjects of his international best seller, The DevOps 2.0 Toolkit, and shows you how to successfully integrate Docker Swarm into your DevOps toolset. Viktor shares with you his expert knowledge in all aspects of building, testing, deploying, and monitoring services inside Docker Swarm clusters. You'll go through all the tools required for running a cluster. You'll travel through the whole process with clusters running locally on a laptop. Once you're confident with that outcome, Viktor shows you how to translate your experience to different hosting providers like AWS, Azure, and DigitalOcean. Viktor has updated his DevOps 2.0 framework in this book to use the latest and greatest features and techniques introduced in Docker. We'll go through many practices and even more tools. While there will be a lot of theory, this is a hands-on book. You won't be able to complete it by reading it on the metro on your way to work. You'll have to read this book while in front of the computer and get your hands dirty. Style and approach We'll go through many practices and even more tools. While there will be a lot of theory, this is a hands-on book. You'll have to read this book while in front of the computer and get your hands dirty. The goal is not to master one particular set of tools, but to learn the logic behind them so that you can apply it to your job in various contexts.

    Throughout the book, we benchmark everything — with some surprising results. We implement custom data structures with value semantics and copy-on-write behavior such as sorted arrays, binary trees, red-black trees, and B-trees.Even if you never implement your own collections, this book helps you reason about the performance of Swift code.

    With a focus on reusing existing code, it quickly and easily shows you how to create basic Java objects, work with Java classes and methods, understand the value of variables, learn to control program flow with loops or decision-making statements, and so much more! Java is everywhere, runs on almost any computer, and is the engine that drives the coolest applications. Written for anyone who’s ever wanted to tackle programming with Java but never knew quite where to begin, this bestselling guide is your ticket to success! Featuring updates on everything you’ll encounter in Java 9—and brimming with tons of step-by-step instruction—it’s the perfect resource to get you up and running with Java in a jiffy! Discover the latest features and tools in Java 9 Learn to combine several smaller programs to create a bigger program Create basic Java objects and reuse code Confidently handle exceptions and events If you’re ready to jump into Java, this bestselling guide will help keep your head above water!

    Parallel computation is powerful and increasingly accessible and multicore computation is incorporated into all sorts of applications, including finance software, video games, web applications, machine-learning, and market analysis. To get the best performance, your application has to partition and divide processing to take full advantage of multicore processors. Functional languages help developers support concurrency by encouraging immutable data structures that can be passed between threads without having to worry about a shared state, all while avoiding side effects.Functional Concurrency in .NET teaches you how to build concurrent and scalable programs in .NET using the functional paradigm. This intermediate-level guide is aimed at developers, architects, and passionate computer programmers who are interested in writing code with improved speed and effectiveness by adopting a declarative and pain-free programming style. You'll start by learning the foundations of concurrency and important functional techniques and paradigms used in the rest of the book. Then you'll dive in to concurrent and parallel programming designs, emphasizing the functional paradigm with both theory and practice with lots of code samples. The third part of the book covers a real "cradle to grave" application implementation, covering the techniques and skills learned during the book.

    imagine you lived in a world were you could use JavaScript to change the universe around you, to tamper with the threads that compose reality as you know it and do anything that you can imagine. Well, welcome to the world of JavaScript-mancy, where wizards, also known as JavaScriptmancers, control the arcane winds of magic wielding JavaScript to and fro and command the very fabric of reality. We, programmers, sadly do not live in such a world. But we do have a measure of magic in ourselves, we have the skills and power to create things out of nothingness. And even if we cannot throw fireballs or levitate (yet), we can definitely change/improve/enhance reality and the universe around us with our little creations. Ain't that freaking awesome? Well, I hope this book inspires you to continue creating, and using this beautiful skill we share, this time, with JavaScript ;). For many years JavaScript has been frowned upon and looked down on by many developers due to its quirky nature, obscure behaviors and many WTFs that populate its hairy APIs and operations. Frown upon no more! For with modern design patterns, libraries, tools and the long awaited ECMAScript 6 (ES6, ES2015) writing JavaScript is now a pleasure. Join me at the school of JavaScript-mancy as we travel along the modern landscape of writing JavaScript in 2015 and beyond, as we discover the organic evolution of this beautiful language and its thriving ecosystem, and delve in the latest features/spells/incantations of the JavaScript Arcana. You my friend, can no longer ignore JavaScript. JavaScript is the most deployed language on earth, a beautiful and expressive language that supports many paradigms and which has a thriving community that continuously expands and improves its ecosystem with patterns, libraries, frameworks and tools. You don't want to miss this train. But JavaScript, though forgiving and specially conceived to be easy to learn, can be either daunting for us that have a strongly-typed mindset and come from languages such as C# or Java or, more often, laughed at as a toy. For you who consider it daunting and hate working with it worry not! I will show you the most common misconceptions and all the patterns you need to know to become as fluent in JavaScript as you are in C#. For you who consider it a toy language, something associated not with real programming but with copy-paste coding or scripting to add flare to websites, I will show you all the different patterns and programming paradigms that JavaScript supports and which make it just as good and powerful as C#. Let's get our JavaScript adventure started! This is the second book of the JavaScript-mancy series. Within its mysterious pages you'll find: * A great introduction to OOP in JavaScript full of fantasy inspired examples and exercises * A detailed look at the pillars of OOP in JavaScript adapted for developers with a C# background * An awesome walkthrough of how to achieve classical inheritance in JavaScript with and without ES6 classes * A step beyond classical inheritance into new OOP paradigms that take advantage of the dynamic nature of JavaScript to bring super flexibility and composability into your apps * A look into the obscure object internals and meta-programming with the new Reflect API, Proxies and Symbols * A thorough introduction to TypeScript and how it can boost your developer productivity * A lot of references to C# that will make it super easy for C# and Java developers to wrap their heads around JavaScript and its quirks.

     Book Description Unity has established itself as an overpowering force for developing mobile games. If you love mobile games and want to learn how to make them but have no idea where to begin, then this book is just what you need. This book takes a clear, step-by-step approach to building an endless runner game using Unity with plenty of examples on how to create a game that is uniquely your own.Starting from scratch, you will build, set up, and deploy a simple game to a mobile device. You will learn to add touch gestures and design UI elements that can be used in both landscape and portrait mode at different resolutions. You will explore the best ways to monetize your game projects using Unity Ads and in-app purchases before you share your game information on social networks. Next, using Unity's analytics tools you will be able to make your game better by gaining insights into how players like and use your game. Finally, you'll learn how to publish your game on the iOS and Android App Stores for the world to see and play along. What you will learn Use Unity to build an endless runner game Set up and deploy a project to a mobile device Create interesting gameplay elements using inputs from your mobile device Monetize your game projects with Unity ads and in-app purchases Design UI elements that can be used well in Landscape and Portrait mode at different resolutions, supporting phones, tablets, and PCs. How to submit your game to the iOS and Android app stores Table of Contents Building your Game Setup for Android & iOS Development Mobile Input / Touch Controls Resolution Independent UI Advertising using Unity Ads Implementing In-App Purchases Getting Social Using Unity Analytics Making our title juicy Game Build & Submission

    For beginners, web sites like Code.org and Khan Academy can provide at least some of that background, along with the Thinking in C seminar freely available at the OnJava8 Site. Services like YouTube, blogs and StackOverflow have made finding answers ridiculously easy compared to just a few years ago when we relied on print media. Combine these with perseverance, and you can use this book as your first programming text. It’s also intended for professional programmers who want to expand their knowledge.

    You'll learn how to face a project with a modular mindset, and how to organize your applications into simple pieces that work well in isolation and can be combined to create a large, robust application.This book focuses on two aspects of JavaScript development: modularity and ES6 features. You ll learn how to tackle application development by following a scale-out approach. As pieces of your codebase grow too big, you can break them up into smaller modules.

    About This Book - Boost your productivity as a C++ developer with the latest features of C++17 - Develop high-quality, fast, and portable applications with the varied features of the STL - Migrate from older versions (C++11, C++14) to C++17 Who This Book Is For This book is for developers who would like to master the C++ STL and make full use of its components. Prior C++ knowledge is assumed. What You Will Learn - Make your own iterator types, allocators, and thread pools. - Master every standard container and every standard algorithm. - Improve your code by replacing new/delete with smart pointers. - Understand the difference between monomorphic algorithms, polymorphic algorithms, and generic algorithms. - Learn the meaning and applications of vocabulary type, product type and sum type. In Detail Modern C++ has come a long way since 2011. The latest update, C++17, has just been ratified and several implementations are on the way. This book is your guide to the C++ standard library, including the very latest C++17 features. The book starts by exploring the C++ Standard Template Library in depth. You will learn the key differences between classical polymorphism and generic programming, the foundation of the STL. You will also learn how to use the various algorithms and containers in the STL to suit your programming needs. The next module delves into the tools of modern C++. Here you will learn about algebraic types such as std:: optional, vocabulary types such as std:: function, smart pointers, and synchronization primitives such as std:: atomic and std:: mutex. In the final module, you will learn about C++'s support for regular expressions and file I/O. By the end of the book you will be proficient in using the C++17 standard library to implement real programs, and you'll have gained a solid understanding of the library's own internals. Style and approach This book takes a concise but comprehensive approach to explaining and applying the C++ STL, one feature at a time.

    What You Will Learn - Install and configure the Go development environment to quickly get started with your first program - Use the basic elements of the language including source code structure, variables, constants, and control flow primitives - Get to know all the basic syntax and tools you need to start coding in Go - Create unique instances that cannot be duplicated within a program - Build quirky and fun projects from scratch while exploring patterns, practices, and techniques, as well as a range of different technologies - Create websites and data services capable of massive scaling using Go's net/http package, - Explore RESTful patterns as well as low-latency WebSocket APIs - Interact with a variety of remote web services to consume capabilities, ranging from authentication and authorization to a fully functioning thesaurus In Detail The Go programming language has firmly established itself as a favorite for building complex and scalable system applications. Go offers a direct and practical approach to programming that lets programmers write correct and predictable code using concurrency idioms and a full-featured standard library. This practical guide is full of real-world examples to help you get started with Go in no time at all. You'll start by understanding the fundamentals of Go, then get a detailed description of the Go data types, program structures, and Maps. After that, you'll learn how to use Go concurrency idioms to avoid pitfalls and create programs that are exact in expected behavior. Next, you will get familiar with the tools and libraries that are available in Go to write and exercise tests, benchmarking, and code coverage. After that, you will be able to utilize some of the most important features of GO such as Network Programming and OS integration to build efficient applications. Then you'll start applying your skills to build some amazing projects in Go. You will learn to develop high-quality command-line tools that utilize the powerful shell capabilities and perform well using Go's built-in concurrency mechanisms. Scale, performance, and high availability lie at the heart of our projects, and the lessons learned throughout the sections will arm you with everything you need to build world-class solutions. You will get a feel for app deployment using Docker and Google App Engine. Each project could form the basis of a start-up, which means they are directly applicable to modern software markets. With these skills in hand, you will be able to conquer all your fears of application development and go on to build large, robust and succinct apps in Go. 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: 1. Learning Go Programming 2. Go Design Patterns 3. Go Programming Blueprints, Second Edition Style and approach Full of real-world, practical examples, this course teaches you the widely used design patterns and best practices in Go in a step-by-step manner. It also provides fun projects that involve building applications from scratch.

    CSS lets developers and designers define what a web page looks like and how it behaves, including how elements are positioned in the browser. Most CSS tutorials teach the subject in isolation, showing you how to make individual changes to things like text color or font size, without showing you how to put everything together as an integrated whole. This approach is a lot like trying to teach a foreign language by having students read the dictionary. You might learn lots of words, but you would end up with little to no context or ability to have a real conversation.In contrast, Learn Enough CSS & Layout to Be Dangerous is specifically designed to show you how CSS works in the context of a real website.No other front-end development tutorial puts everything together in quite the same way. By the end, you'll be able to design, build, and deploy a full, industrial-strength website.

    Not only will you learn to find bugs faster, but you’ll also learn how other developers have solved problems similar to yours. You'll also learn how to create custom, powerful debugging scripts that will help you quickly find the secrets behind any bit of code that piques your interest.Who This Book Is ForThis book is for intermediate to advanced iOS/macOS developers who are already familiar with either Swift or Objective-C and want to take their debugging skills to the next level.Topics Covered in Advanced Apple Debugging & Reverse EngineeringLLDB Max Achievement: Master LLDB and learn about its extensive list of subcommands and options.1's and 0's: Learn the low-level components available to help extract useful information from a program, from assembly calling conventions to exploring the process of dynamically-loaded frameworks.The Power of Python: Use LLDB’s Python module to create powerful custom debugging commands to introspect and augment existing programs.Nothing is Secret: Learn how to use Dtrace, a dynamic tracing framework, and how to write D scripts to query anything you were ever curious about on your macOS machine.Case Studies: Quickly find and solve the real-world issues that iOS and macOS developers typically face in their day-to-day development workflow.After reading this book, you'll have the tools and knowledge to answer even the most obscure question about your code — or someone else’s.

    Its balance of usability, visualization, and widespread use makes it one of the most powerful tools in a scientist's toolbox. In this book, Mike Cohen teaches brain scientists how to program in MATLAB, with a focus on applications most commonly used in neuroscience and psychology. Although most MATLAB tutorials will abandon users at the beginner's level, leaving them to sink or swim, MATLAB for Brain and Cognitive Scientists takes readers from beginning to intermediate and advanced levels of MATLAB programming, helping them gain real expertise in applications that they will use in their work.The book offers a mix of instructive text and rigorous explanations of MATLAB code along with programming tips and tricks. The goal is to teach the reader how to program data analyses in neuroscience and psychology. Readers will learn not only how to but also how not to program, with examples of bad code that they are invited to correct or improve. Chapters end with exercises that test and develop the skills taught in each chapter. Interviews with neuroscientists and cognitive scientists who have made significant contributions their field using MATLAB appear throughout the book. MATLAB for Brain and Cognitive Scientists is an essential resource for both students and instructors, in the classroom or for independent study.

     Build a health tracking system, and indoor navigation and warehouse weather monitoring projects using smart devices. Build on a theoretical foundation and create a practice-based understanding of Bluetooth Low Energy. Book Description Bluetooth Low Energy, or Bluetooth Smart, is Wireless Personal Area networking aimed at smart devices and IoT applications. BLE has been increasingly adopted by application developers and IoT enthusiasts to establish connections between smart devices.This book initially covers all the required aspects of BLE, before you start working on IoT projects. In the initial stages of the book, you will learn about the basic aspects of Bluetooth Low Energy—such as discovering devices, services, and characteristics—that will be helpful for advanced-level projects. This book will guide you through building hands-on projects using BLE and IoT. These projects include tracking health data, using a mobile App, and making this data available for health practitioners; Indoor navigation; creating beacons using the Raspberry Pi; and warehouse weather Monitoring. This book also covers aspects of Bluetooth 5 (the latest release) and its effect on each of these projects.By the end of this book, you will have hands-on experience of using Bluetooth Low Energy to integrate with smart devices and IoT projects. What you will learn Learn about the architecture and IoT uses of BLE, and in which domains it is being used the most Set up and learn about various development platforms (Android, iOS, Firebase, Raspberry Pi, Beacons, and GitHub) Create an Explorer App (Android/iOS) to diagnose a Fitness Tracker Design a Beacon with the Raspberry Pi and write an app to detect the Beacon Write a mobile app to periodically poll the BLE tracking sensor Compose an app to read data periodically from temperature and humidity sensors Explore more applications of BLE with IoT Design projects for both Android and iOS mobile platforms About the Author Madhur Bhargava holds a bachelor's degree in electronics and communication, after which he did a specialization in Wireless and Mobile Computing at CDAC ACTS Pune, India. He started his career at Electronic Arts as a trainee software engineer working on mobile games and eventually moved on to address problems in personalized healthcare, leveraging the power of mobile computing.He is proficient in various mobile/embedded technologies and strives to be a software generalist. Since the inception of his career, he has worked extensively with various mobile technologies, such as Android, iOS, J2ME, Brew, Blackberry OS, and Xamarin. He has designed and developed Bluetooth Low Energy applications pertaining to the healthcare and automation domains for both Android and iOS platforms.He believes that good software is the result of talented individuals working together as a communicative team in an Agile manner. He is both a Certified Scrum Master and a Certified Xamarin Developer.Apart from work, he likes to spend time with family, read, and watch movies. Table of Contents What is Bluetooth Low Energy Setting Up Building a Service Explorer App Designing a Personnel Tracking System Beacons with Raspberry Pi Weather monitoring Using BLE in Warehouses &lt

    You’ll build an app from start to finish and learn:- How to build a web app with the ASP.NET Core framework- The basics of the MVC (Model-View-Controller) pattern- How to read and write data to a database- How to add log-in, registration, and security- How to deploy the app to the webDon’t worry, you don’t need to know anything about ASP.NET Core (or any of the above) to get started.

    This cloud computing architecture e-book focuses on architecture, design, and implementation—considerations that apply no matter which cloud platform you choose. The guide includes steps for:Choosing the right cloud application architecture style for your app or solution.Selecting appropriate compute and data store technologies.Incorporating 10 design principles to build a scalable, resilient, and manageable application.Following the five pillars of software quality to ensure your cloud app is successful.Using design patterns that specifically apply to the problem you’re trying to solve.Download the 300-page cloud architecture e-book to explore these best practices, and get access to design review checklists, reference architectures, and more.

    This up-to-date guide focuses entirely on performance optimization for macOS and iOS. Drawing on more than 25 years of experience optimizing Apple device software, Weiher identifies concrete performance problems that can be discovered empirically via measurement. Then, based on a deep understanding of fundamental principles, he presents specific techniques for solving them. Weiher presents insights you won't find anywhere else, most of them applying to both macOS and iOS development. Throughout, he reveals common pitfalls and misconceptions about Apple device performance, explains the realities, and helps you reflect those realities in code that performs beautifully.Understand optimization principles, measurement, tools, pitfalls, and techniques Recognize when to carefully optimize, and when it isn't worth your time Balance performance and encapsulation to create efficient object representations, communication, data access, and computation Avoid mistakes that slow down Objective-C programs and hinder later optimization Fix leaks and other problems with memory and resource management Address I/O issues associated with drives, networking, serialization, and SQLite Code graphics and UIs that don't overwhelm limited iOS device resources Learn what all developers need to know about Swift performance This book's source code can be downloaded at github.com/mpw/iOS-macOS-performance. Register your product at informit.com/register for convenient access to downloads, updates, and corrections as they become available. Normal 0 false false false EN-US X-NONE X-NONE

    I will never do a big bang release again. What scares me is not what happens if the release does not work, but what happens if it does not work and yet still appears to.Most developers, even those working through big bang releases, have dealt with the versioning of software before. For example, they write SQL migration scripts to convert the old schema to the new one. But have you ever written SQL migration scripts to convert from the new schema with data added to it back to the old schema without losing information? What happens if, later, you get a catastrophic failure on the new release?On teams I have worked with in the past, you got your choice: the fireman helmet or the cowboy hat. In other words, the fireman helmet means if you are working on a production issue, people know not bother you unless they have something material to your issue. I highly recommend this, as at least you get to keep a smile on your face while you are working live in production. To be fair, who wouldn’t want to wear a fireman helmet at work?In modern systems, however, this is not acceptable. The days of maintenance windows and big bang releases are over. Instead, we now focus on releasing parts of software, and often end up wanting to run multiple versions of software side by side. We can no longer update every consumer when a producer is released. We are forced to deal with versioning issues. We are forced to deal with 24/7/365 operations.There are many forces pushing us in this direction. We could talk about the move towards SOA/MicroServices, Continuous Deployment, core ideas from the business side, lossed opportunities and reputational risk.Many of the strategies discussed apply to messaging systems in general. Event Sourced systems also face these kinds of versioning issues in a unique way, as they represent an append-only model. A projection, for instance, needs to be able to read an event that was written two years ago, even though use-cases may have changed.What happens when you have mistakenly written an event in production? If we are to say an event is immutable and the model is append-only, many complications arise.Over the years, I have met many developers who run into issues dealing with versioning, particularly in Event Sourced systems. This seems odd to me. As we will discuss, Event Sourced systems are in fact easier to version than structural data in most instances, as long as you know the patterns for how to version, where they apply, and the trade-offs between the options.

    With this hands-on book, Java developers will learn not only about the joys of modularity, but also about the patterns needed to create truly modular and reliable applications. Authors Sander Mak and Paul Bakker teach you the concepts behind the Java 9 module system, along with the new tools it offers. You’ll also learn how to modularize existing code and how to build new Java applications in a modular way. Understand Java 9 module system concepts Master the patterns and practices for building truly modular applications Migrate existing applications and libraries to Java 9 modules Use JDK 9 tools for modular development and migration

    Nim combines the speed of C with the expressiveness of Python and the flexibility of Lisp and it compiles to C as well as C++, Objective C, and even JavaScript. Nim's features make it perfect for developing anything from web applications to operating systems.Nim in Action introduces the Nim programming language and teaches readers how to write native software applications and libraries, web applications, embedded device software, and programs that communicate over the internet. This book is full of hands-on examples that teach how to test, debug, document, and package Nim applications. It also reveals how to interface with foreign languages such as C and C++ and how to use metaprogramming features to write domain specific languages. This book demonstrates how to implement a fully-functioning chat server, a Twitter clone, and many other software projects. It provides readers with a solid knowledge of Nim and the ability to use it to write powerful, portable and efficient applications.Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications.

    Unfortunately, our actions too often sabotage our best efforts, producing frustrated teams, poor software quality and driving away our best developers. This book is a mirror for you to reflect on your leadership efforts. It is not for the feint of heart, but for those who are willing to bravely ask, "Do I have this habit?" Based on my 20 years of managing software teams, and coaching other technical leaders, this book points out 7 ways you could be unwittingly hurting your programmers, eroding trust and undercutting motivation and productivity. Chapters include: 1. Withholding feedback until the time is right 2. Forgetting how difficult good programming is 3. Fixing other people's mistakes 4. Not expressing gratitude 5. Constantly pushing the team to deliver faster 6. Breaking promises, no matter how small 7. Taking special privileges Each chapter discusses WHY this is a problem, HOW it can ruin your team, and WHAT you can do to correct it.

    For those who know nothing about coding, getting to grips with the basics is daunting. Too many of the beginner books launch straight into programming techniques but what is really needed is an understanding of the key concepts of coding. Programming then becomes much easier to grasp. This accessible, fun book goes right back to the very basics, teaching central concepts such as loops, data types, pseudocode and calculations without having to learn a single line of code! Using a set of dice, a deck of cards or a pack of dominoes to enjoy fun and straightforward exercises, you will practise key skills such as critical thinking, creativity, logic and problem-solving and begin to think like a coder without even turning on your computer.Once you are equipped with this basic toolkit, Think Like a Coder discusses the basic programmes that are available for beginners, keeping a focus on simple activities that draw analogies with the outside world to make learning easy and fun. Suitable for absolute beginners, adults and children.Designed to be a thorough yet lighthearted introduction for the complete beginner, Think Like a Coder is an essential addition to any keen programmer’s bookshelf.