Programming and scripting languages: general Books

Book SynopsisBrings Semantic Web practice to enterprise. Fabien Gandon joins Dean Allemang and Jim Hendler, to open up the story to a modern view of global linked data. Examples have been brought up to date and applied in a modern setting, where enterprise and global data come together as a living, linked network of data.Table of Contents Preface What is the Semantic Web? Semantic modeling RDF—the basis of the Semantic Web Semantic Web application architecture Linked data Querying the Semantic Web—SPARQL Extending RDF: RDFS and SCHACL RDF Schema RDFS-Plus Using RDFS-Plus in the wild SKOS—managing vocabularies with RDFS-Plus Basic OWL Counting and sets in OWL Ontologies on the Web—putting it all together Good and bad modeling practices Expert modeling in OWL Conclusions and future work Bibliography

Read more less

Book SynopsisGetting Started with the Intel Galileo gets you up and running with this new, x86-powered board that was developed in collaboration between Arduino and Intel. You'll learn how to set it up, connect it to your computer, and begin programming.

Read more less

Book SynopsisThis book shows you how to plan your wearable circuits, sew with electronics, and write programs that run on the FLORA to control the electronics. The FLORA family includes an assortment of sensors, as well as RGB LEDs that let you add lighting to your wearable projects.

Read more less

Book SynopsisLearn how to program your nifty new $35 computer to make a web spider, a weather station, a media server, and more. This book explores how to make a variety of fun and even useful projects, from a web bot to search and download files to a toy to drive your pets insane. Even if you''re completely new to programming in general, you''ll see how easy it is to create a home security system, an underwater photography system, an RC plane with a camera, and even a near-space weather balloon with a camera.  You''ll learn how to use Pi with Arduino as well as Pi with Gertboard, an expansion board with an onboard ATmega microcontroller. Learn Raspberry Pi Programming with Python has been fully updated in this new edition to cover the features of the new boards. You''ll learn how to program in Python on your Raspberry Pi with hands-on examples and fun projects.  What You''ll Learn Set up your new Raspberry Pi<Trade Review“Donat (independent scholar) provides a volume that is about equally divided between background material (Python, Circuits, the Raspberry Pi) and a set of stimulating ‘maker’ projects that combine coding, circuit-building, and mechanical construction. The writing style is casual but clear. … the determined hobbyist with sufficient experience will find the background material useful and the projects challenging, stimulating, and rewarding, and the book likewise serves as a useful resource for libraries hosting makerspaces.” (C. Vickery, Choice, Vol. 56 (6), February, 2019)Table of ContentsLearn Raspberry Pi Programming with Python · Chapter 1: Introduction to the Raspberry Pi · Chapter 2: Linux by the Seat of Your Pants · Chapter 3: Introduction to Python · Chapter 4: Electronics at 100 MPF · Chapter 5: The Web bot · Chapter 6: The Weather Station · Chapter 7: The Media Server · Chapter 8: The Home Security System · Chapter 9: The Cat Toy · Chapter 10: The Radio-controlled Airplane · Chapter 11: The Weather Balloon · Chapter 12: The Submersible · Chapter 13: The Raspberry Pi and the Arduino ·

Read more less

Book SynopsisRely on this robust and thorough guide to build and maintain successful test automation. As the software industry shifts from traditional waterfall paradigms into more agile ones, test automation becomes a highly important tool that allows your development teams to deliver software at an ever-increasing pace without compromising quality. Even though it may seem trivial to automate the repetitive tester''s work, using test automation efficiently and properly is not trivial. Many test automation endeavors end up in the graveyard of software projects. There are many things that affect the value of test automation, and also its costs. This book aims to cover all of these aspects in great detail so you can make decisions to create the best test automation solution that will not only help your test automation project to succeed, but also allow the entire software project to thrive.One of the most important details that affects the success of the test automation is Table of Contents Part 1: The “Why” and the “What”.- Chapter 1: The Value of Test Automation.- Chapter 2: From Manual to Automated Testing.- Chapter 3: People and Tools.- Chapter 4: Reaching Full Coverage.- Chapter 5: Business Processes.- Chapter 6: Test Automation and Architecture.- Chapter 7: Isolation and Test Environments.- Chapter 8: The Big Picture.- Part 2: The “How”.- Chapter 9: Preparing for the Tutorial.- Chapter 10: Designing the First Test Case.- Chapter 11: Start Coding the First Test.- Chapter 12: Completing the First Test.- Chapter 13: Investigating Failure.- Chapter 14: Adding More Tests.- Chapter 15: Continuous Integration.- Chapter 16: Acceptance Test Driven Development.- Chapter 17: Unit tests and TDD.- Chapter 18: Other Types of Automated Tests.- Chapter 19: Where to Go from Here.- Appendix A: Real-World Examples.- Appendix B: Cleanup Mechanism.- Appendix C: Test Automation Essentials.- Appendix D: Tips and Practices for Programmer’s Productivity.-

Read more less

Book Synopsis Gain insights into image-processing methodologies and algorithms, using machine learning and neural networks in Python. This book begins with the environment setup, understanding basic image-processing terminology, and exploring Python concepts that will be useful for implementing the algorithms discussed in the book. You will then cover all the core image processing algorithms in detail before moving onto the biggest computer vision library: OpenCV. You''ll see the OpenCV algorithms and how to use them for image processing.  The next section looks at advanced machine learning and deep learning methods for image processing and classification. You''ll work with concepts such as pulse coupled neural networks, AdaBoost, XG boost, and convolutional neural networks for image-specific applications. Later you''ll explore how models are made in real time and then deployed using various DevOps tools.  All the concepTable of ContentsChapter 1: Installation and Environment Setup Chapter Goal: Making System Ready for Image Processing and Analysis No of pages 20 Sub -Topics (Top 2) 1. Installing Jupyter Notebook 2. Installing OpenCV and other Image Analysis dependencies 3. Installing Neural Network Dependencies Chapter 2: Introduction to Python and Image Processing Chapter Goal: Introduction to different concepts of Python and Image processing Application on it. No of pages: 50 Sub - Topics (Top 2) 1. Essentials of Python 2. Terminologies related to Image Analysis Chapter 3: Advanced Image Processing using OpenCV Chapter Goal: Understanding Algorithms and their applications using Python No of pages: 100 Sub - Topics (Top 2): 1. Operations on Images 2. Image Transformations Chapter 4: Machine Learning Approaches in Image Processing Chapter Goal: Basic Implementation of Machine and Deep Learning Models, which takes care of Image Processing, before applications in real-time scenario No of pages: 100 Sub - Topics (Top 2): 1. Image Classification and Segmentation 2. Applying Supervised and Unsupervised Learning approaches on Images using Python Chapter 5: Real Time Use Cases Chapter Goal: Working on 5 projects using Python, applying all the concepts learned in this book No of pages: 100 Sub - Topics (Top 5): 1. Facial Detection 2. Facial Recognition 3. Hand Gesture Movement Recognition 4. Self-Driving Cars Conceptualization: Advanced Lane Finding 5. Self-Driving Cars Conceptualization: Traffic Signs Detection Chapter 6: Appendix A Chapter Goal: Advanced concepts Introduction No of pages: 50 Sub - Topics (Top 2): 1. AdaBoost and XGBoost 2. Pulse Coupled Neural Networks

Read more less

Book SynopsisLearn, understand, and implement deep neural networks in a math- and programming-friendly approach using Keras and Python. The book focuses on an end-to-end approach to developing supervised learning algorithms in regression and classification with practical business-centric use-cases implemented in Keras.The overall book comprises three sections with two chapters in each section. The first section prepares you with all the necessary basics to get started in deep learning. Chapter 1 introduces you to the world of deep learning and its difference from machine learning, the choices of frameworks for deep learning, and the Keras ecosystem. You will cover a real-life business problem that can be solved by supervised learning algorithms with deep neural networks. You''ll tackle one use case for regression and another for classification leveraging popular Kaggle datasets. Later, you will see an interesting and challenging part of deep learning: hyperparameter tuning; Table of ContentsSECTION 1: Prepares the reader with all the necessary gears to get started on the fast track ride in deep learning. Chapter 1: Deep Learning & Keras Chapter Goal: Introduce the reader to the deep learning and keras framework Sub -Topics 1. Exploring the popular Deep Learning frameworks2. Overview of Keras, Pytorch, mxnet, Tensorflow, 3. A closer look at Keras: What’s special about Keras? Chapter 2: Keras in Action Chapter Goal: Help the reader to engage with hands-on exercises with Keras and implement the first basic deep neural network Sub - Topics 1. A closer look at the deep learning building blocks 2. Exploring the keras building blocks for deep learning 3. Implementing a basic deep neural network with dummy data SECTION 2 – Help the reader embrace the core fundamentals in simple lucid language while abstracting the math and the complexities of model training and validation with the least amount of code without compromising on flexibility, scale and the required sophistication Chapter 3: Deep Neural networks for Supervised Learning Chapter Goal: Embrace the core fundamentals of deep learning and its development Sub - Topics: 1. Introduction to supervised learning 2. Classification use-case – implementing DNN 3. Regression use-case – implementing DNN Chapter 4: Measuring Performance for DNN Chapter Goal: Aid the reader in understanding the craft of validating deep neural networks Sub - Topics: 1. Metrics for success – regression 2. Analyzing the regression neural network performance 3. Metrics for success – classification 4. Analyzing the regression neural network performance SECTION 3 – Tuning and deploying robust DL models Chapter 5: Hyperparameter Tuning & Model Deployment Chapter Goal: Understand how to tune the model hyperparameters to achieve improved performance Sub - Topics: 1. Hyperparameter tuning for deep learning models 2. Model deployment and transfer learning Chapter 6: The Path Forward Chapter goal – Educate the reader about additional reading for advanced topics within deep learning. Sub - Topics: 1. What’s next for deep learning expertise? 2. Further reading 3. GPU for deep learning 4. Active research areas and breakthroughs in deep learning5. Conclusion

Read more less

Book SynopsisImplement numerical algorithms in Java using NM Dev, an object-oriented and high-performance programming library for mathematics.You'll see how it can help you easily create a solution for your complex engineering problem by quickly putting together classes.Numerical Methods Using Java covers a wide range of topics, including chapters on linear algebra, root finding, curve fitting, differentiation and integration, solving differential equations, random numbers and simulation, a whole suite of unconstrained and constrained optimization algorithms, statistics, regression and time series analysis. The mathematical concepts behind the algorithms are clearly explained, with plenty of code examples and illustrations to help even beginners get started. What You Will Learn Program in Java using a high-performance numerical library Learn the mathematics for a wide range of numerical computing algorithms Trade Review“The book is primarily a user’s guide to the NM DEV commercial software library … .” (Anthony J. Duben, Computing Reviews, December 6, 2022)Table of ContentsTable of ContentsAbout the Authors...........................................................................................................iPreface............................................................................................................................ii1. Why Java?..............................................................................................................61.1. Java in 2020.....................................................................................................61.2. Java vs. C++....................................................................................................61.3. Java vs. Python................................................................................................61.4. Java in the future .............................................................................................62. Data Structures.......................................................................................................72.1. Function...........................................................................................................72.2. Polynomial ......................................................................................................73. Linear Algebra .......................................................................................................83.1. Vector and Matrix ...........................................................................................83.1.1. Vector Properties .....................................................................................83.1.2. Element-wise Operations.........................................................................83.1.3. Norm ........................................................................................................93.1.4. Inner product and angle ...........................................................................93.2. Matrix............................................................................................................103.3. Determinant, Transpose and Inverse.............................................................103.4. Diagonal Matrices and Diagonal of a Matrix................................................103.5. Eigenvalues and Eigenvectors.......................................................................103.5.1. Householder Tridiagonalization and QR Factorization Methods..........103.5.2. Transformation to Hessenberg Form (Nonsymmetric Matrices)...........104. Finding Roots of Single Variable Equations .......................................................114.1. Bracketing Methods ......................................................................................114.1.1. Bisection Method ...................................................................................114.2. Open Methods...............................................................................................114.2.1. Fixed-Point Method ...............................................................................114.2.2. Newton’s Method (Newton-Raphson Method) .....................................114.2.3. Secant Method .......................................................................................114.2.4. Brent’s Method ......................................................................................115. Finding Roots of Systems of Equations...............................................................125.1. Linear Systems of Equations.........................................................................125.2. Gauss Elimination Method............................................................................125.3. LU Factorization Methods ............................................................................125.3.1. Cholesky Factorization ..........................................................................125.4. Iterative Solution of Linear Systems.............................................................125.5. System of Nonlinear Equations.....................................................................126. Curve Fitting and Interpolation............................................................................146.1. Least-Squares Regression .............................................................................146.2. Linear Regression..........................................................................................146.3. Polynomial Regression..................................................................................146.4. Polynomial Interpolation...............................................................................146.5. Spline Interpolation .......................................................................................147. Numerical Differentiation and Integration...........................................................157.1. Numerical Differentiation .............................................................................157.2. Finite-Difference Formulas...........................................................................157.3. Newton-Cotes Formulas................................................................................157.3.1. Rectangular Rule....................................................................................157.3.2. Trapezoidal Rule....................................................................................157.3.3. Simpson’s Rules.....................................................................................157.3.4. Higher-Order Newton-Coles Formulas..................................................157.4. Romberg Integration .....................................................................................157.4.1. Gaussian Quadrature..............................................................................157.4.2. Improper Integrals..................................................................................158. Numerical Solution of Initial-Value Problems....................................................168.1. One-Step Methods.........................................................................................168.2. Euler’s Method..............................................................................................168.3. Runge-Kutta Methods...................................................................................168.4. Systems of Ordinary Differential Equations.................................................169. Numerical Solution of Partial Differential Equations..........................................179.1. Elliptic Partial Differential Equations...........................................................179.1.1. Dirichlet Problem...................................................................................179.2. Parabolic Partial Differential Equations........................................................179.2.1. Finite-Difference Method ......................................................................179.2.2. Crank-Nicolson Method.........................................................................179.3. Hyperbolic Partial Differential Equations.....................................................1710..................................................................................................................................1811..................................................................................................................................1912. Random Numbers and Simulation ....................................................................2012.1. Uniform Distribution .................................................................................2012.2. Normal Distribution...................................................................................2012.3. Exponential Distribution............................................................................2012.4. Poisson Distribution ..................................................................................2012.5. Beta Distribution........................................................................................2012.6. Gamma Distribution ..................................................................................2012.7. Multi-dimension Distribution ....................................................................2013. Unconstrainted Optimization ............................................................................2113.1. Single Variable Optimization ....................................................................2113.2. Multi Variable Optimization .....................................................................2114. Constrained Optimization .................................................................................2214.1. Linear Programming..................................................................................2214.2. Quadratic Programming ............................................................................2214.3. Second Order Conic Programming............................................................2214.4. Sequential Quadratic Programming...........................................................2214.5. Integer Programming.................................................................................2215. Heuristic Optimization......................................................................................2315.1. Genetic Algorithm .....................................................................................2315.2. Simulated Annealing .................................................................................2316. Basic Statistics..................................................................................................2416.1. Mean, Variance and Covariance................................................................2416.2. Moment......................................................................................................2416.3. Rank...........................................................................................................2417. Linear Regression .............................................................................................2517.1. Least-Squares Regression..........................................................................2517.2. General Linear Least Squares....................................................................2518. Time Series Analysis ........................................................................................2618.1. Univariate Time Series..............................................................................2618.2. Multivariate Time Series ...........................................................................2618.3. ARMA .......................................................................................................2618.4. GARCH .....................................................................................................2618.5. Cointegration .............................................................................................2619. Bibliography .....................................................................................................2720. Index .....................................................................................................

Read more less

Book SynopsisLearn the ins and outs of decisions, biases, and reliability of AI algorithms and how to make sense of these predictions. This book explores the so-called black-box models to boost the adaptability, interpretability, and explainability of the decisions made by AI algorithms using frameworks such as Python XAI libraries, TensorFlow 2.0+, Keras, and custom frameworks using Python wrappers. You'll begin with an introduction to model explainability and interpretability basics, ethical consideration, and biases in predictions generated by AI models. Next, you'll look at methods and systems to interpret linear, non-linear, and time-series models used in AI. The book will also cover topics ranging from interpreting to understanding how an AI algorithm makes a decisionFurther, you will learn the most complex ensemble models, explainability, and interpretability using frameworks such as Lime, SHAP, Skater, ELI5, etc. Moving forward, youwill be introduced to model explainability for unstructurTrade Review“Practical explainable AI using Python combines textbook and cookbook elements. It provides explanations of concepts along with practical examples and exercises. … this book offers a comprehensive foundation that will remain relevant for some time. However, readers should supplement their knowledge with the latest research in order to stay up to date in this dynamic field.” (Gulustan Dogan, Computing Reviews, August 21, 2023)“While the book presents just fundamental aspects, I find this to be a great advantage. Indeed, even the layperson to AI/ML can use this work: the author starts with the most basic definitions and models, and then provides software examples … . This way a very broad readership is possible, since more advanced parts of the chapters will be interesting even for specialists in AI/ML who would like to increase their expertise in the title topic.” (Piotr Cholda, Computing Reviews, April 17, 2023)Table of ContentsChapter 1: Introduction to Model Explainability and InterpretabilityChapter Goal: This chapter is to understand what is model explainability and interpretability using Python. No of pages: 30-40 pages Chapter 2: AI Ethics, Biasness and Reliability Chapter Goal: This chapter aims at covering different frameworks using XAI Python libraries to control biasness, execute the principles of reliability and maintain ethics while generating predictions.No of pages: 30-40Chapter 3: Model Explainability for Linear Models Using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by linear models for supervised learning task, for structured dataNo of pages : 30-40Chapter 4: Model Explainability for Non-Linear Models using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by non-linear models, such as tree based models for supervised learning task, for structured dataNo of pages: 30-40Chapter 5: Model Explainability for Ensemble Models Using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by ensemble models, such as tree based ensemble models for supervised learning task, for structured data No of pages: 30-40Chapter 6: Model Explainability for Time Series Models using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by time series models for structured data, both univariate time series model and multivariate time series modelNo of pages: 30-40Chapter 7: Model Explainability for Natural Language Processing using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by models from text classification, summarization, sentiment classification No of pages: 30-40Chapter 8: AI Model Fairness Using What-If ScenarioChapter Goal: This chapter explains use of Google’s WIT Tool and custom libraries to explain the fairness of an AI modelNo of pages: 30-40Chapter 9: Model Explainability for Deep Neural Network ModelsChapter Goal: This chapter explains use of Python libraries to interpret the neural network models and deep learning models such as LSTM models, CNN models etc. using smooth grad and deep shiftNo of pages: 30-40Chapter 10: Counterfactual Explanations for XAI modelsChapter Goal: This chapter aims at providing counterfactual explanations to explain predictions of individual instances. The "event" is the predicted outcome of an instance, the "cause" are the particular feature values of this instance that were the input to the model that "caused" a certain prediction.No of pages: 30-40Chapter 11: Contrastive Explanation for Machine LearningChapter Goal: In this chapter we will use foil trees: a model-agnostic approach to extracting explanations for finding the set of rules that causes the explanation to be predicted the actual outcome (fact) instead of the other (foil)No of pages: 20-30Chapter 12: Model-Agnostic Explanations By Identifying Prediction InvarianceChapter Goal: In this chapter we will use anchor-LIME (a-LIME), a model-agnostic technique that produces high-precision rule-based explanations for which the coverage boundaries are very clear.No of pages: 20-30Chapter 13: Model Explainability for Rule based Expert System Chapter Goal: In this chapter we will use anchor-LIME (a-LIME), a model-agnostic technique that produces high-precision rule-based explanations for which the coverage boundaries are very clear.No of pages: 20-30Chapter 14: Model Explainability for Computer Vision.Chapter Goal: In this chapter we will use Python libraries to explain computer vision tasks such as object detection, image classification models.No of pages: 20-30

Read more less

Book SynopsisLearn the fundamentals of the Java 17 LTS or Java Standard Edition version 17 Long Term Support release, including basic programming concepts and the object-oriented fundamentals necessary at all levels of Java development.Table of Contents1. Programming Concepts 2. Setting Up the Environment 3. Writing Java Programs 4. Data Types 5. Operators 6. Statements 7. Classes and Objects 8. Methods 9. Constructors 10. Modules11. Object and Objects Classes 12. Wrapper Classes 13. Execution Handling 14. Assertions 15. Strings 16. Dates and Times 17. Formatting Data 18. Regular Expressions 19. Arrays 20. Inheritance 21. Interfaces 22. Enum Types 23. Java Shell Appendix A: Character Encodings Appendix B: Documentation Comments

Read more less

Book SynopsisGo from competent C++ developer to skilled designer or architect using this book as your personal C++ design master class. Updated for the C++20 standard, this title will guide you through the design and implementation of an engaging case study that forms the backdrop for learning the art of applying design patterns and modern C++ techniques to create a high quality, robust application.  Starting with a quick exploration of the requirements for building the application, you''ll delve into selecting an appropriate architecture, eventually designing and implementing all of the necessary modules to meet the project''s requirements. By the conclusion of Practical C++ Design, you''ll have constructed a fully functioning calculator capable of building and executing on any platform that supports both Qt and C++20. Access to the complete source code will help speed your learning. Utilize the Model-View-Controller pattern as the basis for the architecTable of ContentsPreface (5 pages)The preface details my motivation for writing the book, the target audience for the book, thegeneral structure of the book, and how to contact the author. Of particular importance is therationale behind choosing the case study, the target language (C++), and the GUI toolkit (Qt).Chapter 1: Defining the Case Study (6 pages)The first chapter describes, in detail, the case study to be examine in the book. The chapterdiscusses requirements in the abstract and then transitions to the calculator’s specific requirements.This sets the stage for the remainder of the book, which describes, in detail, the design andimplementation of the calculator, pdCalc, proposed in Chapter 1.1. A Brief Introduction2. A Few Words About Requirements3. Reverse Polish Notation (RPN)4. The Calculator’s Requirements5. The Source Code1The advice, information, and conclusions discussed in this book are those of the author and have not beenendorsed by, or reflect the opinions or practices of, ExxonMobil Corporation or its affiliates.5Chapter 2: Decomposition (18 pages)In this chapter, I explain the elements of a good decomposition and strategies for decomposing aproblem into manageable pieces. Subsequently, an architecture for pdCalc is selected, the calculatoris modularized, and use cases are used to develop interfaces for the high level calculator modules.The four high level modules are the stack, the command dispatcher, the user interface (subdividedinto a command line interface and a graphic user interface), and a plugin manager.1. The Elements of a Good Decomposition2. Selecting An Architecture3. Interfaces4. Assessment of Our Current Design5. Next StepsChapter 3: The Stack (20 pages)The stack is the first module discussed in detail. The stack is the fundamental data repositoryof the calculator. As part of the calculator’s design and implementation, the singleton pattern isexplored. The stack also affords the first opportunity to discuss an event system for the calculator,which provides a backdrop for exploration of the observer pattern, including the design andimplementation of reusable publisher and observer abstract classes.1. Decomposition of the Stack Module2. The Stack Class3. Adding Events4. A Quick Note on TestingChapter 4: The Command Dispatcher (32 pages)This chapter describes the design and implementation of the command dispatcher, the module ofthe calculator responsible for the creation, storage, and execution of commands. Of particular notein this chapter is the exposition on the command pattern and how it can be used to implement apractical undo/redo framework. In addition to exploring a traditional deep hierarchy method forimplementing commands, a C++11 alternative using lambda expressions and the standard functiontemplate are presented as a modern alternative design.1. The Decomposition of the Command Dispatcher2. The Command Class3. The Command Repository4. The Command Manager5. The Command Dispatcher6. Revisiting Earlier Decisions6Chapter 5: The Command Line Interface (14 pages)This chapter marks an important milestone, the creation of the first user executable program.In addition to building a simple command line interface, we’ll explore how to create an abstractsoftware interface suitable for both a command line interface and a graphical user interface. Withinthe context of the command line interface, we’ll learn techniques for simple parsing and tokenizingof input text streams.1. The User Interface Abstraction2. The Concrete CLI Class3. Tying It Together: A Working ProgramChapter 6: The Graphical User Interface (24 pages)In this chapter, we build the Qt-based graphical user interface for the calculator. Here, we’llexamine different strategies for building GUIs, abstraction of GUI elements, and modularization ofthe overall GUI design. Included in the discussion is design for the separation of on-screen widgetsfrom look-and-feel.1. Requirements2. Building GUIs3. Modularization4. A Working Program5. A Microsoft Windows Build NoteChapter 7: Plugins (38 pages)In this chapter, I describe how to build a cross-platform plugin system. This system includes theabstract interface for C++ plugins as well as the operating system specific mechanics involved withloading plugins and executing plugin functions. In the concrete case of the plugin loader, I explainthe many build tricks that can be used to handle cross-platform code and demonstrate how theabstract factory pattern provides an elegant design solution to this problem.1. What Is a Plugin?2. Problem 1: The Plugin Interface3. Problem 2: Loading Plugins4. Problem 3: Retrofitting pdCalc5. Incorporating Plugins6. A Concrete Plugin7. Next Steps7Chapter 8: New Requirements (24 pages)Any developer who has ever worked on a production software project quickly learns that newrequirements are always added late in the development cycle. In this chapter, we explore theaddition of new user requests after the original requirements have already been satisfied. Thediscussion progresses from fully implemented solutions to design only solutions to vague ideas forthe reader to explore on her own.1. Fully Designed New Features2. Designs Toward a More Useful Calculator3. Some Interesting Extensions for Self-ExplorationAppendix A: Acquiring, Building, and Executing pdCalc (4 pages)This appendix explains how to download the source code from GitHub and how to build the casestudy on Linux and Windows. Once the program is built, readers will want to execute the codeand its included test suite; execution instructions are therefore provided.1. Getting The Source Code2. Dependencies3. Building pdCalc4. Executing pdCalcAppendix B: Organization of the Source Code (6 pages)This appendix simply explains the organization of the source tree for pdCalc. This appendix isuseful for finding the locations for the source files referenced in the text.1. The src Directory2. The test DirectoryReferences (2 pages)This section lists twenty-nine references cited in the book.Index (3 pages)This section is a complete index for the book.

Read more less

Book SynopsisLearn the core aspects of NumPy, Matplotlib, and Pandas, and use them to write programs with Python 3. This book focuses heavily on various data visualization techniques and will help you acquire expert-level knowledge of working with Matplotlib, a MATLAB-style plotting library for Python programming language that provides an object-oriented API for embedding plots into applications.You'll begin with an introduction to Python 3 and the scientific Python ecosystem. Next, you'll explore NumPy and ndarray data structures, creation routines, and data visualization. You'll examine useful concepts related to style sheets, legends, and layouts, followed by line, bar, and scatter plots. Chapters then cover recipes of histograms, contours, streamplots, and heatmaps, and how to visualize images and audio with pie and polar charts.Moving forward, you'll learn how to visualize with pcolor, pcolormesh, and colorbar, and how to visualize in 3D in Matplotlib, create simple animations, and embed MatplTable of ContentsChapter 1: Getting Started with Python and Jupyter Notebook Chapter Goal: Introduce the reader to the basics of Python programming language, philosophy, and installation. We will also learn how to install it on various platforms. This chapter also introduces the readers to Python programming with Jupyter notebook. In the end, we will also have a brief overview of the constituent libraries of SciPy stack. No of pages - 26 Sub -Topics • Python Programming Language • Installing Python on various platforms • Python Modes • Python IDEs • Scientific Python Ecosystem • Overview of Jupyter Notebook • Setting up Jupyter Notebook • Running Code in Jupyter Notebook Chapter 2: Getting Started with NumPy Chapter Goal: Get started with NumPy Ndarrays and basics of NumPy library. The chapter covers the instructions for installation and basic usage of NumPy. No of pages: 9 Sub - Topics: · Introduction to the NumPy Ndarrays · Ndarray Properties · NumPy Constants Chapter 3 : NumPy Routines and Getting started with Matplotlib Chapter goal – In this chapter, we will discuss the various Ndarray creation routines available in NumPy. We will also get started with visualizations with Matplotlib. We will learn how to visualize the various numerical ranges with Matplotlib. No of pages: 15 Sub - Topics: · Routines for creating Ndarrays · Matplotlib · Visualization with NumPy and Matplotlib Chapter 4 : Revisiting Matplotlib Visualizations Chapter goal – This chapter is focused on learning the details of Matplotlib styles for visualizing NumPy Ndarrays. No of pages: 24 Sub - Topics: • Single Line Plots • Multiline plots • Grid, Axes, and Labels • Colors, Lines, and Markers • Subplots • Object Oriented Style • Working with the text Chapter 5 : Styles and Layouts Chapter goal – This chapter is focused on learning the details of Matplotlib styles and layouts. No of pages: 12 Sub - Topics: 1. Styles 2. layouts Chapter 6 : Line, Bar, and Scatter Plots Chapter goal – In this chapter, we will learn how to create nice visualizations with lines, bars, and scatter. No of pages: 14 Sub - Topics: · Lines and Logs · Errorbar · Bar Graphs · Scatter Plot Chapter 7 : Histograms, Contours, and Streamplots Chapter goal – In this chapter, we will learn how to create nice visualizations histograms, contours, and streamplots. No of pages: 15 Sub - Topics: • Histograms • Contours • Plot vector entities with streamplots Chapter 8 : Image and Audio Visualization Chapter goal – Learn to work with Image Processing using NumPy and Matplotlib. Also learn how to process and visualize audio data as waveforms. No of pages: 15 Sub - Topics: • Visualizing images • Interpolation Methods • Audio Visualization • Audio Processing Chapter 9 : Pie and Polar Charts Chapter goal – Learn to work with Pie and Polar charts. No of pages: 12 Sub - Topics: 1. Pie charts 2. Polar charts Chapter 10 : PColor, Pcolormesh, and Colorbar Chapter goal – In this chapter, we will learn Pcolor, Pcolormesh, and colorbar. No of pages: 10 Sub - Topics: 1. PColor 2. Pcolormesh 3. Colorbar Chapter 11 : 3D Visualizations in Matplotlib Chapter goal – In this chapter, we will learn how to create 3D visualizations. No of pages: 17 Sub - Topics: • Getting Ready • Plotting 3D Line • 3D Scatter plot • 3D Contours • Wireframe, Surface, and Sample Data • Bar graphs • Quiver and Stemplot • 3D Volumes Chapter 12 : Animations with Matplotlib Chapter goal – In this chapter, we will learn how to create simple animations with Matplotlib. No of pages: 8 Sub - Topics: • Animation Basics • Celluloid library Chapter 13 : More Recipes of Visualizations with Matplotlib Chapter goal – In this chapter, we will learn more types of visualizations with Matplotlib. No of pages: 14 Sub - Topics: · Visualizing Function as an image and a contour · 3D Vignette · Decorated Scatter Plots · Time plots and Signals · Filled Plots · Step Plots · Hexbins · XKCD Style Chapter 14 : Introduction to Pandas Chapter goal – Get started with Pandas data structures No of pages: 10 Sub - Topics: • Introduction to Pandas • Series in Pandas • Dataframe in Pandas Chapter 15 : Data Acquisition Chapter goal – Read the data from various sources No of pages: 18 Sub - Topics: • Plain Text File Handling • Handling CSV with Python • Python and Excel • Writing and reading files with NumPy • Reading the data from a CSV file with NumPy • Matplotlib CBook • Reading data from a CSV • Reading data from an Excel • Reading data from JSON • Reading data from Pickle • Reading data from Web • Reading data from Relation databases • Reading Data from the clipboard Chapter 16 : Visualizing Data with Pandas and Matplotlib Chapter goal – Get started with Data Visualization with Matplotlib No of pages: 25 • Simple Plots • Bar Graphs • Histogram • Box Plot • Area Plots • Scatter Plot • Hexagonal Bin Plot • Pie Charts Chapter 17 : Introduction to Data Visualization with Seaborn Chapter goal – Get started with Pandas and seaborn No of pages: 20 Sub - Topics: • What is Seaborn? • Plotting statistical Relationships • Plotting Lines • Visualizing the distribution of data Chapter 18 : Visualizing real-life Data with Matplotlib and Seaborn Chapter goal – Get started with COVID and Animal disease datasets and Visualize them No of pages: 20 Sub - Topics: • COVID-19 Pandemic Data • Fetching the Pandemic Data Programmatically • Preparing the data for visualization • Visualization with Matplotlib and Seaborn • Visualization of Animal Disease Data

Read more less

Book SynopsisGet started quickly with IntelliJ, from installation to configuration to working with the source code and more. This tutorial will show you how to leverage IntelliJ's tools to develop clean, efficient Java applications. Author Ted Hagos will first walk you through buidling your first Java applications using IntelliJ. Then, he'll show you how to analyze your application, top to bottom; using version control and tools that allow you expand your application for big data or data science applications and more. You'll also learn some of the IDE's advanced features to fully maximize your application's capabilities.The last portion of the book focuses on application testing and deployment, and language- and framework- specific guidelines. After reading this book and working through its freely available source code, you'll be up to speed with this powerful IDE for today's Java development.What You Will LearnUse IntelliJ IDEA to build Java applicationsSet up your IDE and projectWork with sourcTable of Contents1. Install IntelliJ2. Getting Started3. Configuring the IDE4. Configuring Projects5. Working with Source Code6. Building Applications7. Analyzing Applications8. Version Control9. Big Data / Data Science Tools10. Other Tools11. Advanced IDE Features12. Migration Guides13. Language and Framework Specific Guidelines14. Testing 15. Deployment

Read more less

Book SynopsisDesign and build innovative, custom, data-driven Alexa skills for home or business. Working through several projects, this book teaches you how to build Alexa skills and integrate them with online APIs. If you have basic Python skills, this book will show you how to build data-driven Alexa skills. You will learn to use data to give your Alexa skills dynamic intelligence, in-depth knowledge, and the ability to remember. Data-Driven Alexa Skills takes a step-by-step approach to skill development. You will begin by configuring simple skills in the Alexa Skill Builder Console. Then you will develop advanced custom skills that use several Alexa Skill Development Kit features to integrate with lambda functions, Amazon Web Services (AWS), and Internet data feeds. These advanced skills enable you to link user accounts, query and store data using a NoSQL database, and access real estate listings and stock prices via web APIs. What You Will LearnSet up and configure your development environmTable of ContentsPart I: Getting Started Chapter 1: Voice User Interfaces Chapter 2: Routines and Blueprints Chapter 3: The Developer Accounts Chapter 4: Creating the VUI for a Custom Data-driven Skill Chapter 5: Writing the Back-end Code Chapter 6: Publishing an Alexa Skill Part II: Custom Skill Development Chapter 7: Custom Alexa Skills Chapter 8: Beyond Hello World Chapter 9: Configuring the VUI Chapter 10: Using APL to Present on Screens Chapter 11: Coding the Lambda Function Chapter 12: Unit Testing an Alexa Skill Chapter 13: Storing the Data Part III: Using APIs in Advanced Skills Chapter 14: A Personal Net Worth Skill Chapter 15: The Real Estate API Chapter 16: The Stock Market API Chapter 17: What’s Next?

Read more less

Book SynopsisDesign and develop Java-based RESTful APIs using the latest versions of the Spring MVC and Spring Boot frameworks. This book walks you through the process of designing and building a REST application while delving into design principles and best practices for versioning, security, documentation, error handling, paging, and sorting. Spring RESTprovides a brief introduction to REST, HTTP, and web infrastructure. You will learn about several Spring projects such as Spring Boot, Spring MVC, Spring Data JPA, and Spring Security, and the role they play in simplifying REST application development. You will learn how to build clients that consume REST services. Finally, you will learn how to use the Spring MVC test framework to unit test and integration test your REST API. After reading this book, you will come away with all the skills to build sophisticated REST applications using Spring technologies. What You Will LearnBuild Java-based microservices, native cloud, or any applications uTable of Contents1. Introduction to REST2. Spring MVC & Spring Boot Primer3. RESTful Spring4. Beginning the QuickPoll Application5. Error Handling6. Documenting REST Services7. Versioning, Paging, and Sorting8. Security9. Clients and Testing10. HATEOASA. Installing cURL on Windows

Read more less

Book SynopsisGet started quickly with Qt, the popular open source C++ framework for building C++-based applications and games. This book will have you building both fully functional desktop and mobile applications in no time, including some simple game applications.  Introducing Qt 6 begins by guiding you in setting up your tools and environment, and then walks you through the first baby steps of Qt framework. Next, you''ll learn the basics of how project and app structure are set up using Qt. Then, you''ll begin your first real hands-on projects using Qt, including a task and problem management application and two games.  As you progress, you can enhance these apps and games using additional Qt components and features. The book then delves into advanced topics in Qt, learning above and beyond what the Qt docs can offer, including local storage, C++ integration, deployment to Windows and Android, custom components and how to work with them. UpTable of ContentsPart 11. IntroductionPart 2 - Content2. Setting up the Tools 3. First Baby Steps with Qt4. Explaining the Basics of Project and App Structure5. First Real Projects6. Taskmaster7. Hang-Man Game8. Rock, Paper, Scissors GamePart 3 - Components, Features and Things9. Components10. Features 11. Writing Diagrams in Qt12. Advanced Topics in Qt

Read more less

Book SynopsisQuickly find solutions to dozens of common programming problemsencountered while building Java applications, with recipes presented in the popular problem-solution format. Look up the programming problem that you want to resolve. Read the solution. Apply the solution directly in your own code. Problem solved!Java 17 Recipes is updated to reflect changes in specification and implementation since the Java 9 edition of this book. Java 17 is the next long-term support release (LTS) of the core Java Standard Edition (SE) version 17 which also includes some of the features from previous short term support (STS) releases of Java 16 and previous versions.This new edition covers of some of the newest features, APIs, and more such as pattern matching for switch, Restore Always-Strict-Floating-Point-Semantics, enhanced pseudo-random number generators, the vector API, sealed classes, and enhancements in the use of String. Source code for all recipes is available in a dedicated GitHub repository. Table of Contents1. Getting Started with Java 172. Java 17 Enhancements3. Strings4. Numbers and Dates5. Object-Oriented Java6. Lambda Expressions7. Data Structures and Collections8. Input and Output9. Exceptions and Logging10. Concurrency11. Debugging and Unit Testing12. Unicode, Internationalization, and Currency Codes13. Working with Databases14. JavaFX Fundamentals15. Graphics with JavaFX16. Media with JavaFX17. Java Web Applications18. Nashorn and Scripting19. E-mail20. JSON and XML Processing21. Networking22. Java Modularity

Read more less

Book SynopsisUse the step-by-step approach of this book to learn and implement design patterns in real-world applications. It focuses on classical design patterns with Java 17 and Eclipse (2021-09). In addition to Gang of Four (GoF) design patterns, the book covers popular and alternative design patterns and includes criticisms of design patterns in a chapter on anti-patterns. The book is divided into four parts. Part one covers the SOLID design principles and the Simple Factory pattern. Part two covers the 23 (GoF) design patterns, including the creational patterns, structural patterns, and behavioral patterns. Part three covers alternative design patterns, including the Null Object pattern, and the model-view-controller (MVC) pattern. Part four covers criticisms of design patterns with a quick overview of anti-patterns. It also includes a chapter on FAQs on design patterns.The book also includes a chapter on FAQs on design patterns. Each pattern is explained with realTable of Contents Part-I: FoundationChapter 1: SOLID PrinciplesChapter Goal: To discuss all the 5 fundamental design principles-SRP, OCP, LSP, ISP, and DIPSub - Topics SRP, OCP, LSP, ISP, and DIPChapter 2: Simple Factory PatternChapter Goal: To discuss the simple factory pattern a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. It is the foundation for the factory method pattern and abstract factory pattern in Part II.Part-II: Gang of Four Design Patterns2.A: Creational PatternsChapter 3: Factory Method PatternChapter Goal: To discuss the factory method pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 4: Abstract Factory PatternChapter Goal: To discuss the abstract factory pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 5: Prototype PatternChapter Goal: To discuss the prototype pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 6: Builder PatternChapter Goal: To discuss the builder pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 7: Singleton PatternChapter Goal: To discuss the singleton pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. 2.B: Structural PatternsChapter 8: Proxy PatternChapter Goal: To discuss the proxy pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 9: Decorator PatternChapter Goal: To discuss the decorator pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 10: Adapter PatternChapter Goal: To discuss the adapter pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 11: Facade PatternChapter Goal: To discuss the facade pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 12: Flyweight PatternChapter Goal: To discuss the flyweight pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 13: Composite PatternChapter Goal: To discuss the composite pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 14: Bridge PatternChapter Goal: To discuss the bridge pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. 2.C: Behavioral PatternsChapter 15: Visitor PatternChapter Goal: To discuss the visitor pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 16: Observer PatternChapter Goal: To discuss the observer pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 17: Strategy PatternChapter Goal: To discuss the strategy pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 18: Template Method PatternChapter Goal: To discuss the template method pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 19: Command PatternChapter Goal: To discuss the command pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 20: Iterator PatternChapter Goal: To discuss the iterator pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 21: Memento PatternChapter Goal: To discuss the memento pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 22: State PatternChapter Goal: To discuss the state pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 23: Mediator PatternChapter Goal: To discuss the mediator pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 24: Chain of Responsibility PatternChapter Goal: To discuss the chain of responsibility pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 25: Interpreter PatternChapter Goal: To discuss the interpreter pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Part-II: Additional Design PatternsChapter 26: Null Object PatternChapter Goal: To discuss the null object pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 27: MVC PatternChapter Goal: To discuss the MVC pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Part-III: Final talks on Design PatternsChapter 28: Criticism to Design PatternsChapter Goal: To discuss the criticism to design patternsChapter 29: Brief overview of Anti-PatternsChapter Goal: To discuss the anti-patternsChapter 30: FAQChapter Goal: This chapter will consist of the frequently asked questions to help readers with a quick revision. This chapter will also clear the doubts that may arise among similar patterns.

Read more less

Book SynopsisDiscover what's new in C# and .NET for Windows programming. This book isa condensed code and syntax reference to the C# programming language, updated with the latest features of version 10 for .NET 6.You'll review the essential C# 10 and earlier syntax, not previously covered, in a well-organized format that can be used as a handy reference. Specifically, unions, generic attributes, CallerArgumentExpression, params span, Records,Init only setters,Top-level statements,Pattern matching enhancements,Native sized integers,Function pointers and more. You'll find a concise reference to the C# language syntax: short, simple, and focused code examples; a well laid out table of contents; and a comprehensive index allowing easy review. You won't find any technical jargon, bloated samples, drawn-out history lessons, or witty stories. What you will find is a language reference that is to the point and highly accessible.The book is a must-have for any C# programmer. What You Will LearnEmploy nuTable of Contents1. Hello World2. Compile and Run3. Variables4. Operators5. Strings6. Arrays7. Conditionals8. Loops9. Methods10. Class11. Inheritance12. Redefining Members13. Access Levels14. Static15. Properties16. Indexers17. Interfaces18. Abstract19. Namespaces20. Enum21. Exception Handling22. Operator Overloading23. Custom Conversions24. Struct25. Preprocessors26. Delegates27. Events28. Generics29. Constants30. Asynchronous Methods

Read more less

Book SynopsisOptimize, develop, and design PyTorch and TensorFlow models for a specific problem using the Microsoft Neural Network Intelligence (NNI) toolkit. This book includes practical examples illustrating automated deep learning approaches and provides techniques to facilitate your deep learning model development. The first chapters of this book cover the basics of NNI toolkit usage and methods for solving hyper-parameter optimization tasks. You will understand the black-box function maximization problem using NNI, and know how to prepare a TensorFlow or PyTorch model for hyper-parameter tuning, launch an experiment, and interpret the results. The book dives into optimization tuners and the search algorithms they are based on: Evolution search, Annealing search, and the Bayesian Optimization approach. The Neural Architecture Search is covered and you will learn how to develop deep learning models from scratch. Multi-trial and one-shot searching approaches of automatic neural networTable of ContentsChapter 1: Introduction to Neural Network Intelligence1.1 Installation1.2 Trial, search space, experiment1.3 Finding maxima of multivariate function1.4 Interacting with NNIChapter 2:Hyper-Parameter Tuning2.1 Preparing a model for hyper-parameter tuning2.2 Running experiment2.3 Interpreting results2.4 DebuggingChapter 3: Hyper-Parameter TunersChapter 4: Neural Architecture Search: Multi-trial4.1 Constructing a search space4.2 Running architecture search4.3 Exploration strategies4.4 Comparing exploration strategiesChapter 5: Neural Architecture Search: One-shot5.1 What is one-shot NAS?5.2 ENAS5.3 DARTSChapter 6: Model Compression6.1 What is model compression?6.2 Compressing your model6.3 Pruning6.4 QuantizationChapter 7: Advanced NNI

Read more less

Book SynopsisExplore the world of programming languages through Python and learn the building blocks of writing programs. This book covers Python 3.10, explaining it through six key concepts. Each chapter contains a real-world example with practical advice and a section on advanced concepts. You''ll start by reviewing the concept of expressions and functions, which are two of the core building blocks of programming languages.  You''ll then move on to object-oriented concepts to help gain a practical understanding of Python, along with a chapter on control flow constructs. The book also takes a close look at sequences, explaining constructs and additional types, and wraps up with a chapter on modules, focusing on how to use and create packages. Whether you''re new to programming or already an experienced developer, upon finishing this book, you will have a solid understanding of Python''s state-of-the-art development features.WhatTable of ContentsChapter 1: Expression- Explains expression as the first key concept of a programming language.1.1. What is an expression?1.2. Expressions containing different types1.3. Variable names1.4. Statements1.5. Deleting variable names1.6. Further language constructs1.7. Expressions and statements in practice1.8. References:Chapter 2: Function- Explains function as the second most important building block.2.1. What is a function?2.2. Calling functions2.3. Functions with side effects2.4. Function parameters2.5. Defining functions2.6. Referencing to variable and function names2.7. Function as parameter2.8. Embedded function definitions2.9. Function in practice2.10. ReferencesChapter 3: Class- Explains object-oriented concepts as everything is an object in Python.3.1. What is object-oriented programming?3.2. What is a class?3.3. Creating objects3.4. Using attributes and methods3.5. Defining classes3.6. Connection between classes3.7. Properties3.8. Inheritance3.9. Embedded classes3.10. Special methods3.11. Classes in practice3.12. ReferencesChapter 4. Control flow- Explains what control flow constructs and everything related to it (exceptions, recursion, etc.)4.1. What is control flow?4.2. Conditional statement4.3. Condition-controlled loops4.4. Count-controlled loops4.5. Exception handling4.6. Context management4.7. ReferencesChapter 5: Sequence- Explains the list like constructs and additional container types.5.1. What is a sequence?5.2. List and its operations5.3. List comprehension5.4. Tuples 5.5. Dictionaries5.6. Sets5.7. ReferencesChapter 6: Module- Explains how to use and create packages.6.1. What is a module?6.2. Built-in modules6.3. Create your own modules6.4. Packages6.5. Package management6.6. Interesting third party packages6.7. References

Read more less

Book SynopsisProgramming permeates almost all aspects of our lives. This includes being active on social media, shopping online, and participating in virtual courses. It also includes driving a car and using many devices.  This book will teach you the basics of programming using the Processing programming language and provide practice with logical, algorithmic thinking.  It can provide insight into what is involved in producing the technical infrastructure of our world. While reading this book, you can build programs based on your own ideas, using images you create or acquire and making connections to activities you enjoy.The chapters in the book will demonstrate the process of programming, starting with formulating an idea, planning, building on past projects, and refining the work, similar to writing an essay or composing a song. This approach will guide you to make use of logic and mathematics to produce beautiful effects. The text contains an Appendix with an introductiTable of Contents1. Basics2. Interactions3. Animation Using Arrays and Parallel Structures4. Classes 5. More Interactions6. Images, Graphics, and Building on Prior Work7. Using Files for Making a Holiday Card8. Combining Videos, Images, and Graphics9. Hangman10. 3DAppendix: Processing and JavaScript: p5.js

Read more less

Book SynopsisUnderstand real-world game development concepts using JavaFX game engine called FXGL. The core focus of the book is on developing a standalone game or application with FXGL. We will start with an overview of the book followed by requisite concepts from Java and JavaFX that will be used throughout this book. Next, we will learn about the FXGL game engine and its wide range of real-world game development techniques. In the following chapter, we learn about entity-component model used in FXGL to create a powerful abstraction of the game world. The next chapter builds on this, where we develop a platformer game using the physics engine and a popular external tool called Tiled. An important concept of games AI is covered in the following chapter. Visually complex features related to graphics and rendering as well as UI elements and animation system in FXGL will be discussed in the next chapter. The following chapter is dedicated to non-game applications that can be developed usTable of ContentsChapter 1: IntroductionChapter Goal: Sets the scene for the book, provides an overview and sets expectationsChapter 2: Requisite Java and JavaFX ConceptsChapter Goal: Covers fundamental knowledge required to understand the book contentSub-topics: Java programmingJavaFX scene graphJavaFX model of programmingJavaFX conceptsChapter 3: FXGL ArchitectureChapter Goal: Provides an overview of the FXGL architecture, features, and capabilitiesChapter 4: Entity-Component Case Study: Develop Arcade GamesChapter Goal: Introduction to entity-component model used for abstracting game worldsSub-topics: Game worldEntity-Component modelPong and Breakout style gamesChapter 5: Physics Case Study: Develop a Platformer Game Chapter Goal: Introduction to lightweight and heavyweight physics engines in FXGLSub-topics: Collision detectionRigid body dynamicsMario style gameChapter 6: AI Case Study: Develop a Maze Action GameChapter Goal: Provides a foundation for using and developing AI agents in FXGLSub-topics: A* pathfindingGraph theoryComponent-driven behaviorPac-man style gameChapter 7: Graphics and UI Case Study: Develop a Top-Down Shooter GameChapter Goal: Introduction to the particle and animation systems used in FXGLSub-topics: Particle systemMulti-layer renderingAnimationsInterpolationsGeometry wars style gameChapter 8: Developing General-Purpose ApplicationsChapter Goal: Provide information on how FXGL can be used in non-game contextsChapter 9: Cross-platform DeploymentChapter Goal: Demonstrates the package and deployment process with FXGLSub-topics: jlinkNative imagesGluon toolsMobile developmentChapter 10: ConclusionChapter Goal: Recap what was covered in the chapters, provides external resources and ideas for future projects

Read more less

Book SynopsisReview the fundamental constructs in C# using Q&As and program segments to boost your confidence and gain expertise. This book will help you analyze your programs more efficiently and enhance your programming skills.The book is divided into three parts, where you will learn the fundamentals, object-oriented programming, and some advanced features of C#. In the first part, you will review C# and .NET basics along with the important constructs such as strings, arrays, and structures. In the second part, you''ll review the concepts of object-oriented programming in detail. Here, you will go through various program segments in class and objects, inheritance, polymorphism, abstraction, encapsulation, and much more. You will also analyze the output of the given programs with the help of Q&A sections. The uses of interfaces, static class, and exception handling are discussed in the book along with some other important concepts in C#. In the third and last part, you will learn aTable of ContentsPart I Fundamentals Chapter 1: Language Basics Chapter Goal: This chapter discusses the following topics: The important concepts in .NET The basic programming constructs in C#. Use of some useful data types including the var type. Use of some useful operators and explicit-casting. Use of the selection statements and case guards. Use of iteration statements. Use of the jump statements. Use of the ternary operator. No of pages: 28 Sub - Topics N Chapter 2: String and Arrays Chapter Goal: Once you finish this chapter, you can answer the following questions and related areas: How can you use string datatype in your program? How can you use the common in-built methods from the String class? How a String variable is different from a StringBuilder? How can you convert a string to an int? How can you use nullable reference type in a program? How to create arrays in C#? What are the different types of C# arrays and how to use them? How to use common in-built methods from the System.Array class? How can you iterate over a string or an array? No of pages 23 Sub - Topics NA Chapter 3: Enumeration and Structures Chapter Goal: This chapter discusses the following topics: The enum fundamentals Flags enumeration Defaut value expressions The struct fundamentals Non-destructive mutations No of pages: 26 Sub - Topics NA Part II Object-Oriented Programming Chapter 4: Class and Objects Chapter Goal: This chapter focuses on the following topics: Classes and objects creations. Instance fields and methods. Constructors and their usage. Optional parameters. Object initializers. Nested classes. The uses of private, internal, and public modifiers inside a class. No of pages: 17 Sub - Topics NA Chapter 5: Inheritance Chapter Goal: This chapter covers the following topics: Inheritance and types. Method and constructor overloading. Method overriding. Use of virtual, override, and new keywords. Use of the sealed keyword. Introductory discussion on covariance and contravariance No of pages 33 Sub - Topics NA Chapter 6: Polymorphism Chapter Goal: This chapter helps you to review: Polymorphism and its benefits. Abstract classes and their uses. Interfaces and their uses. Different types of interfaces. Writing polymorphic codes using abstract classes and interfaces No of pages: 30 Sub - Topics NA Chapter 7: Encapsulation Chapter Goal: This chapter covers the following topics: What is encapsulation? How is it different from an abstraction? Properties and their usage. Different ways to create a property. The usage of the get and set accessors. Virtual and abstract properties. The discussion of the init accessor. Indexers and their usage. How can the indexers and properties work with an interface? Discussion on different aspects of properties and indexers. No of pages: 26 Sub - Topics NA Chapter 8: Exception Handling Chapter Goal: This chapter covers the following topics: Exception and its uses in C# programming. Use of the try, catch, and finally blocks. Use of multiple catch blocks in a program. Use of a general catch block. How to throw and re-throw an exception. Use of exception filters. Custom exception class and its usage. No of pages: 23 Sub - Topics NA Chapter 9: Useful Concepts Chapter Goal: Q&A and program segments on some useful constructs such as casting and boxing, static class and methods, passing value type by value, passing value type by references(using ref and out keyword), extension methods, and so on. No of pages: 15-25+ Sub - Topics NA Part III Advanced Features Chapter 10: Delegates Chapter Goal: This chapter covers the following topics: Delegates and their uses Multicast delegates Some commonly used in-built delegates Covariance and contravariance using delegates No of pages: 20 Sub - Topics NA Chapter 11: Events Chapter Goal: This chapter helps you to review your understanding of events and discusses the following: Events creation and their uses. How to pass the event data. Use of event accessors. Use of interface events (both implicit and explicit). Simplified coding with events. No of pages: 22 Sub - Topics NA Chapter 12: Lambdas Chapter Goal: This chapter focuses on this and covers the following topics: Lambda expressions and their use Expression-bodied members Use of local variables inside lambda expressions. Event handling using lambda expressions. Use of a static lambda. Understanding natural type. No of pages: 22 Sub - Topics NA Chapter 13: Generics Chapter Goal: This chapter focuses on the following topics: The motivation behind generics. The fundamentals of generic programs. Use of generic interfaces. Use of generic constraints. Use of covariance and contravariance using generics. Self-referencing generic type. Experimenting with generic method’s overloading and overriding. Analyzing the static data in the context of generics. No of pages: 35 Sub - Topics NA Chapter 14: Multithreading Chapter Goal: Upon completion of this chapter, you’ll be able to answer the following questions: What are the threads and how can you create them? What is a multithreaded program? How does it differ from a single-threaded application? Why are the ThreadStart and ParameterizedThreadStart delegates important in thread programming? How to block a thread using Sleep or Join methods? How can you use lambda expressions in a multithreaded program? How to use important Thread class members? How a foreground thread is different from a background thread? What is synchronization and why is it needed? How can you implement thread safety in C# using lock statements? How can you implement an alternative approach to lock statements using Monitor’s Entry and Exit Method? What is a deadlock and how can you detect the deadlock in your system? What is the purpose of using the ThreadPool class? What are the associative pros and cons of using it? How to cancel a running thread in the managed environment? And many more. No of pages: 40 Sub - Topics NA Chapter 15: Miscellaneous Chapter Goal: Q&A and program segments on the related latest features that are covered in the previous chapters and any other important topics(if any). No of pages: 10-20+ Sub - Topics NA

Read more less

Book SynopsisThis book introduces reinforcement learning with mathematical theory and practical examples from quantitative finance using the TensorFlow library. Reinforcement Learning for Finance begins by describing methods for training neural networks. Next, it discusses CNN and RNN two kinds of neural networks used as deep learning networks in reinforcement learning. Further, the book dives into reinforcement learning theory, explaining the Markov decision process, value function, policy, and policy gradients, with their mathematical formulations and learning algorithms. It covers recent reinforcement learning algorithms from double deep-Q networks to twin-delayed deep deterministic policy gradients and generative adversarial networks with examples using the TensorFlow Python library. It also serves as a quick hands-on guide to TensorFlow programming, covering concepts ranging from variables and graphs to automatic differentiation, layers, models, andloss functions. After completing this boTable of ContentsChapter 1 Overview 1.1 Methods for Training Neural NetworksChapter 2 Convolutional Neural Networks 2.1 A Simple CNN 2.2 Identifying Technical Patterns in Security PricesChapter 3 Recurrent Neural Networks 3.1 LSTM Network 3.2 LSTM Application: Correlation in Asset Returns Chapter 4 Reinforcement Learning 4.1 Basics 4.2 Methods For Estimating MDP 4.3 Value Estimation Methods 4.4 Policy Learning 4.5 Actor-Critic Algorithms 4.6; Implementation of algorithms to quantitative finance using TensorFlow - 1Chapter 5 Recent Advances in Reinforcement Learning Algorithms 5.1 Double Deep Q-Network: DDQN 5.2 Dueling Double Deep Q-Network 5.3 Noisy Networks 5.4 Deterministic Policy Gradient

Read more less

Book SynopsisAs a programming language, Java's object-oriented nature is key to creating powerful, reusable code and applications that are easy to maintain and extend.That being said, many people learn Java syntax without truly understanding its object-oriented roots, setting them up to fail to harness all of the power of Java. This book is your key to learning both!This new third edition of Beginning Java Objects: From Concepts to Codediscusses Java syntax, object principles, and how to properly structure the requirements of an application around an object architecture. It is unique in that it uses a single case study of a Student Registration System throughout the book, carrying the reader from object concepts, to object modeling, to building actual code for a full-blown application. A new chapter covers a technology-neutral discussion of the principles of building a three-tier architecture using Java, introducing the notion of model layer presentation layer data layer separation. Coding eTable of ContentsPart I: The ABCs of ObjectsChapter 1: Abstraction and ModelingChapter Goal: Introducing the mechanism of abstraction as a natural way for humans to interpret the world, and how this relates to object modeling in the software realm.Subtopics:• Simplification through abstraction• Generalization through abstraction• Reusing abstractionsChapter 2: Some Java BasicsChapter Goal: Provide the reader with an immediate introduction to Java language fundamentals so that object concepts can be illustrated using Java code examples as soon as we begin introducing them in chapter 3.Subtopics:• Strengths of the Java language• Primitive Java types• The anatomy of a Java program• Mechanics of compiling and running a Java program• Java’s block structured nature• Elements of Java programming styleChapter 3: Objects and ClassesChapter Goal: Explain the basic building blocks of an OO application – classes as mini-abstractions aka templates for creating object instances.Subtopics:• Advantages of an OO approach to software development over a non-OO approach• How classes are used to specify a type of object’s data • How objects are created (instantiated) at run time• The use of reference variables to refer to objects symbolicallyChapter 4: Object InteractionsChapter Goal: Explain how object behaviors are defined as methods within classes, and how objects collaborate by invoking one another’s methods to accomplish the overall mission of the system.Subtopics:• How methods are used to specify an object’s behaviors• The anatomy of a Java method• How objects send messages to one another to accomplish collaboration• How classes use public and private visibility to publicize what services a type of object can perform while hiding both the logic for how the service is accomplished and the internal data structure needed to support the service• The use of constructors to instantiate the state of an object when first instantiated Chapter 5: Relationships Between ObjectsChapter Goal: Explains the notion of a structural relationship between two objects, wherein the data structures of the classes to which they belong are designed to maintain lasting relationships between objects once instantiated. The two main approaches to accomplishing this are (a) encoding associations between two classes of objects as reference variables within their data structures, (b) having one class inherit and extend the capabilities of another.Subtopics:• Types of structural relationships maintained by objects: associations, aggregations, inheritance• The inheritance mechanism, and guidelines for what we can and cannot achieve when deriving new classes via inheritance• Revisiting constructors regarding some complexities that must be understood when inheritance is involvedChapter 6: Collections of ObjectsChapter Goal: Introduce a special category of objects (classes) known as collections, to be used for efficiently managing an indefinite number of objects of the same type.Subtopics:• The properties of three generic collection types: ordered lists, sets, and dictionaries• The specifics of several different commonly-used built-in Java collection types• The concept of Java packages as logical groupings of classes, and the use of import statements• The power of collections in modeling very sophisticated real-world scenarios• Design techniques for programmer-defined collection typesChapter 7: Some Final Object ConceptsChapter Goal: Covers several key but often misunderstood advanced language features that are essential to taking full advantage of Java’s object-oriented nature: polymorphism (how a single line of code representing a method invocation can exhibit a variety of different behaviors at run time); abstract methods, classes, and interfaces; and static features (data/methods belonging to an entire class of objects versus objects individually).Subtopics:• The runtime mechanism of polymorphism• Abstract classes and methods• The incredible power of interfaces in streamlining Java code• Static featuresPart II: Object Modeling 101Chapter 8: The Object Modeling Process in a NutshellChapter Goal: A high-level overview of how to approach the requirements of a system so as to structure it from the ground up to take advantage of all of the strengths of an OO language like Java.Subtopics:• The goals of and philosophy begin object modeling• Flexibility in terms of selecting or devising a modeling methodology• The pros and cons of using object modeling software toolsChapter 9: Formalizing Requirements Through Use CasesChapter Goal: Explains the importance of developing use cases when establishing requirements for an application, to ensure that (a) all categories of intended user are identified, (b) all of the services that each user category will expect the system to provide, and (c) what their expectations are of the desired outcome for each of the service types.Subtopics:• Introduction to use cases• The notion of actors • Involving users in defining use cases• Approaches to documenting/diagramming use casesChapter 10: Modeling the Data Aspects of the SystemChapter Goal: Illustrate the process by which the types of classes, their respective data structures, and their interrelationships can be discovered and rendered graphically using UML notation.Subtopics:• Technique for identifying the appropriate classes and their respective attributes• Technique for determining the structural relationships that exist among these classes• How to graphically portray this information in proper UML notationChapter 11: Modeling the Behavioral Aspects of the SystemChapter Goal: Revisiting the evolving object model of chapter 10 to reflect the services/behaviors/methods required of each identified class to ensure that the overall requirements of the application will be satisfied.Subtopics:• How the behaviors (method execution) of an object affects its state (data)• Developing scenarios for how use cases (defined in chapter 9) might play out• Creating sequence diagrams based on scenarios• Using sequence diagrams to determine methodsChapter 12: Wrapping Up Our Modeling EffortsChapter Goal: This chapter focuses on ways to test a model before coding begins, as well as Subtopics:• Testing the model• Revisiting requirements and adapting the model as necessary• Reusing models in the form of design patterns Part III: Translating an Object Blueprint into Java CodeChapter 13: A Few More Key Java Details (retitled from 2nd edition)Chapter Goal: Covering a variety of important Java topics that were not essential to illustrating the object concepts of Part I per se, but which are nonetheless key to a rounding out a beginning level Java programmer’s facility with the language. I plan on eliminating a few sections from this chapter if I determine that any of the topics covered are *not* essential to understanding the Student Registration System (SRS) code of chapter 14.Subtopics:• Java application architecture, revisited• Nature and purpose of Java Archive (JAR) files• Java documentation comments• Object nature of Strings• Java enums (enumerations)• Object self-referencing via the “this” keyword• The nature of run-time exceptions, how to handle them, and how to define and use custom exception types• Important features of the built-in Object class• Techniques for command line input• Remove: discussion of inner classes (no longer needed since we are eliminating the chapter on the Swing API)• Remove: narrative regarding Java version 5 language enhancementsChapter 14: Transforming Your Model into Java CodeChapter Goal: In this chapter, I pull together all that we’ve covered in Part I of the book to render the UML model created in Part II of the book into a complete, fully functioning model layer for the Student Registration System. This code can be run from the command line, and will be downloadable from the Apress website.Subtopics: How to code …• … associations of varying multiplicities (one-to-one, one-to-many, many-to-many)• … inheritance relationships• … association classes• … reflexive associations• … abstract classes• … metadata• … static attributes and methodsChapter 15: Three Tier Architectures: Considerations for Adding a User Interface and Data Layer to Your ApplicationChapter Goal: Conceptually introduce the notion of model – presentation layer – data layer separation, using pseudocode examples to illustrate how these layers interact with the model layer code of chapter 14.Subtopics:• Overview of the power of model – presentation layer – data layer separation • Concept of operations for the Student Registration System user interface• Detailed walk-through of pseudocode illustrating (a) how the data layer is used to validate and persist model layer logic, (b) how the user interface/presentation layer is used to receive data and operational requests from a user

Read more less

Book Synopsis Solve SEO problems using data science. This hands-on book is packed with Python code and data science techniques to help you generate data-driven recommendations and automate the SEO workload. This book is a practical, modern introduction to data science in the SEO context using Python. With social media, mobile, changing search engine algorithms, and ever-increasing expectations of users for super web experiences, too much data is generated for an SEO professional to make sense of in spreadsheets. For any modern-day SEO professional to succeed, it is relevant to find an alternate solution, and data science equips SEOs to grasp the issue at hand and solve it. From machine learning to Natural Language Processing (NLP) techniques, Data-Driven SEO with Python provides tried and tested techniques with full explanations for solving both everyday and complex SEO problems. This book is ideal for SEO professionals who want to take their industry skiTable of ContentsData Driven SEO with PythonChapter 1: Meeting the Challenges of SEO with Data1.1 Agents of change in SEO1.2 The Pillars of SEO Strategy1.3 Installing Python1.4 Using Python for SEOChapter 2: Keyword Research2.1 Data Sources2.2 Google Search Console2.4 Google Trends2.5 Google Suggest2.6 Competitor Analytics2.7 SERPsChapter 3: Technical3.1 Improving CTRs3.2 Allocate keywords to pages based on the copy3.3 Allocating parent nodes to the orphaned URLs3.4 Improve interlinking based on copy3.5 Automate Technical AuditsChapter 4: Content & UX4.1 Content that best satisfies the user query4.2 Splitting and merging URLs4.3 Content Strategy: Planning landing page content Chapter 5: Authority5.1 A little SEO history5.1 The source of authority5.2 Finding good linksChapter 6: Competitors6.1 Defining the problem6.2 Data Strategy6.3 Data Sources6.4 Selecting Your Competitors6.5 Get Features6.6 Explore, Clean and Transform6.7 Modelling The SERPS6.8 Evaluating your Model6.9 ActivationChapter 7: Experiments7.1 How experiments fit into the SEO process7.2 Generating Hypotheses7.3 Experiment Design7.4 Running your experiment7.5 Experiment EvaluationChapter 8: Dashboards8.1 Use a Data Layer8.2 Extract, Transform and Load (ETL)8.3 Transform8.4 Querying the Data Warehouse (DW)8.5 Visualization8.6 Making Future ForecastsChapter 9: Site Migrations and Relaunches9.1 Data sources9.2 Establishing the Impact9.3 Segmenting the URLs9.4 Legacy Site URLs9.5 Priority9.6 RoadmapChapter 10: Google Updates10.1 Data sources10.2 Winners and Losers10.3 Quantifying the Impact10.4 Search Intent10.5 Unique URLs10.6 RecommendationsChapter 11: The Future of SEO11.1 Automation11.2 Your journey to SEO science11.3 Suggest resourcesAppendix: CodeGlossaryIndex

Read more less

Book SynopsisThis book explains how to scale Apache Spark 3 to handle massive amounts of data, either via batch or streaming processing. It covers how to use Spark's structured APIs to perform complex data transformations and analyses you can use to implement end-to-end analytics workflows.This book covers Spark 3's new features, theoretical foundations, and application architecture. The first section introduces the Apache Spark ecosystem as a unified engine for large scale data analytics, and shows you how to run and fine-tune your first application in Spark. The second section centers on batch processing suited to end-of-cycle processing, and data ingestion through files and databases. It explains Spark DataFrame API as well as structured and unstructured data with Apache Spark. The last section deals with scalable, high-throughput, fault-tolerant streaming processing workloads to process real-time data. Here you'll learn about Apache Spark Streaming's execution model, the architecture of Spark STable of ContentsPart I. Apache Spark Batch Data ProcessingChapter 1: Introduction to Apache Spark for Large-Scale Data Analytics1.1. What is Apache Spark? 1.2. Spark Unified Analytics1.3. Batch vs Streaming Data1.4. Spark EcosystemChapter 2: Getting Started with Apache Spark2.2. Scala and PySpark Interfaces2.3. Spark Application Concepts2.4. Transformations and Actions in Apache Spark2.5. Lazy Evaluation in Apache Spark2.6. First Application in Spark2.7. Apache Spark Web UIChapter 3: Spark Dataframe APIChapter 4: Spark Dataset APIChapter 5: Structured and Unstructured Data with Apache Spark5.1. Data Sources5.2. Generic Load/Save Functions5.3. Generic File Source Options5.4. Parquet Files5.5. ORC Files5.6. JSON Files5.7. CSV Files5.8. Text Files5.9. Hive Tables5.10. JDBC To Other DatabasesChapter 6: Spark Machine Learning with MLlibPart II. Spark Data StreamingChapter 7: Introduction to Apache Spark Streaming7.1. Apache Spark Streaming’s Execution Model7.2. Stream Processing Architectures7.3. Architecture of Spark Streaming: Discretized Streams7.4. Benefits of Discretized Stream Processing7.4.1. Dynamic Load Balancing7.4.2. Fast Failure and Straggler RecoveryChapter 8: Structured Streaming8.1. Streaming Analytics8.2. Connecting to a Stream8.3. Preparing the Data in a Stream8.4. Operations on a Streaming DatasetChapter 9: Structured Streaming Sources9.1. File Sources9.2. Apache Kafka Source9.3. A Rate SourceChapter 10: Structured Streaming Sinks10.1. Output Modes10.2. Output Sinks10.3. File Sink10.4. The Kafka Sink10.5. The Memory Sink 10.6. Streaming Table APIs10.7. Triggers10.8. Managing Streaming Queries10.9. Monitoring Streaming Queries10.9.1. Reading Metrics Interactively10.9.2. Reporting Metrics programmatically using Asynchronous APIs10.9.3. Reporting Metrics using Dropwizard10.9.4. Recovering from Failures with Checkpointing10.9.5. Recovery Semantics after Changes in a Streaming QueryChapter 11: Future Directions for Spark Streaming11.1. Backpressure11.2. Dynamic Scaling11.3. Event time and out-of-order data11.4. UI enhancements11.5. Continuous ProcessingChapter 12: Watermarks. A deep survey of temporal progress metrics

Read more less

Book SynopsisLearn how to build cloud-native microservices with Helidon - an open-source Java framework from Oracle. This book will show you how to take full advantage of the cloud by optimizing applications with fast start times, low memory consumption, and a small disk footprint. The open-source Helidon framework provides all that, and more. It''s based on Java 17, giving you full access to new code features. This book reveals how Helidon also supports modern enterprise Java standards such as MicroProfile. Plus, you''ll see how Helidon lets you use GraalVM to build lightning-fast native executables, and its unique reactive layer allows you to develop efficient low-level APIs.Each chapter in the book teaches a new Helidon concept through practical examples based on real-life use-cases. You''ll learn how to add observability and security to your microservices, how to work with databases, and call other services. You''ll also look at all MicroProfile 5.0 platform specificationsTable of Contents1:Introduction.- 2: Your First Application.- 3: Configuration.- 4: Observability.- 5: Communicating with other Services.- 6: Accessing Data.- 7: Resiliency.- 8:Security.- 9: Using Open API.- 10: Testing Your Application.- 11: Scheduling Tasks.- 12: Integration with other Technologies.- 13: Going Reactive.- 14: Long Running Actions.- 15: Helidon SE.

Read more less

Book Synopsis1. An Introduction to Data Analysis .- 2. Introduction to the Python's World.- 3. The NumPy Library .- 4. The pandas Library-- An Introduction.- 5. pandas: Reading and Writing Data .- 6. pandas in Depth: Data Manipulation .- 7. Data Visualization with matplotlib .- 8. Machine Learning with scikit-learn.- 9. Deep Learning with TensorFlow.- 10. An Example - Meteorological Data.- 11. Embedding the JavaScript D3 Library in IPython Notebook.- 12. Recognizing Handwritten Digits.- 13. Textual data Analysis with NLTK.- 14. Image Analysis and Computer Vision with OpenCV.- Appendix A.- Appendix B.Table of ContentsPython Data Analytics1. An Introduction to Data Analysis 2. Introduction to the Python's World3. The NumPy Library 4. The pandas Library-- An Introduction5. pandas: Reading and Writing Data 6. pandas in Depth: Data Manipulation 7. Data Visualization with matplotlib 8. Machine Learning with scikit-learn9. Deep Learning with TensorFlow10. An Example - Meteorological Data11. Embedding the JavaScript D3 Library in IPython Notebook12. Recognizing Handwritten Digits13. Textual data Analysis with NLTK 14. Image Analysis and Computer Vision with OpenCV Appendix A Appendix B

Read more less

Book SynopsisMaster the fundamentals of Spring Framework 6 while learning from the real-world experiences of Spring experts. Over the course of this book, you'll learn how to leverage Spring 6 in tandem with the Kotlin programming language to build complex enterprise applications from top to bottom. From monoliths to cloud native apps for streaming microservices, you'll gain insight into every aspect of the process, including transactions, data access, persistence, and web and presentation tiers. As you progress through the book, the authors demonstrate how to run Kotlin with a single command, deploy new utility methods in String class, use Local-Variable Syntax for Lambda Parameters Nested Based Access Control, read/write strings to and from files, and using Flight Recorder. Also, a whole new generation of dependencies are available, and you'll see exactly how to make optimal use of them. A full sample application will show you how to apply Spring 6's new tools and techniques and see how they woTable of ContentsChapter 01 Introducing Spring Framework 6Chapter 02 Getting Started with Spring and KotlinChapter 03 Introducing IoCChapter 04 Spring Configuration In Detail and Spring BootChapter 05 Introducing Spring AOPChapter 06 Using Spring Data JPA with KotlinChapter 07 Using Spring Data JDBC with KotlinChapter 08 Using other Spring Data and Integrating with HibernateChapter 09 Transaction ManagementChapter 10 Validation Conversion FormattingChapter 11 Task SchedulingChapter 12 Using Spring RemotingChapter 13 Spring TestingChapter 14 Scripting Support In SpringChapter 15 Application MonitoringChapter 16 Web Applications and Microservices with Spring MVC and WebFluxChapter 17 WebSocketsChapter 18 Spring Projects Batch, Integration and moreChapter 19. Spring Cloud for Cloud-Native AppsAppendix A Setting Up Your Development Environment

Read more less

Book SynopsisThis book is for those who wish to understand how Python debugging is and can be used to develop robust and reliable AI, machine learning, and cloud computing software. It will teach you a novel pattern-oriented approach to diagnose and debug abnormal software structure and behavior. The book begins with an introduction to the pattern-oriented software diagnostics and debugging process that, before performing Python debugging, diagnoses problems in various software artifacts such as memory dumps, traces, and logs. Next, you'll learn to use various debugging patterns through Python case studies that model abnormal software behavior. You'll also be exposed to Python debugging techniques specific to cloud native and machine learning environments and explore how recent advances in AI/ML can help in Python debugging. Over the course of the book, case studies will show you how to resolve issues around environmental problems, crashes, hangs, resource spikes, leaks, and performancedegradatioTable of ContentsChapter 1: Fundamental Vocabulary.- Chapter 2: Pattern-Oriented Debugging.- Chapter 3: Elementary Diagnostics Patterns.- Chapter 4: Debugging Analysis Patterns.- Chapter 5: Debugging Implementation Patterns.- Chapter 6: IDE Debugging in Cloud.- Chapter 7: Debugging Presentation Patterns.- Chapter 8: Debugging Architecture Patterns.- Chapter 9: Debugging Design Patterns.- Chapter 10: Debugging Usage Patterns.- Chapter 11: Case Study: Resource Leaks.- Chapter 12: Case Study: Deadlock.- Chapter 13: Challenges of Python Debugging in Cloud Computing.- Chapter 14: Challenges of Python Debugging in AI and Machine Learning.- Chapter 15: What AI and Machine Learning Can Do for Python Debugging.- Chapter 16: The List of Debugging Patterns.

Read more less

Book SynopsisFinally, a book on creative programming, written directly for artists and designers! This second edition offers expanded and updated content incorporating the latest advancements and trends in the field of creative programming, also for creatives who want to work directly with P5.js and online. It delves deeper into the intricacies of computational art. Itincludes fresh case studies that explore real-world applications of coding art, inspiring readers to think beyond traditional boundaries. Rather than following a computer science curriculum, this book is aimed at creatives who are working in the intersection of design, art, and education. Following a real-world use case of computation art, you'll see how it relates back to the four key pillars, and addresses potential pitfalls and challenges in the creative process. All code examples are presented in a fully integrated Processing example library, making it easy for readers to get started.This unique and finely balanced approach betwTable of ContentsIntroductionPart I: Creative CodingIn the first main part of this book, we present a four-step working process when code is involved in art practice.Chapter 1: Idea to VisualsIn this chapter we show how creatives can translate their ideas into simple visual elements, and then work with these elements creatively, by animating them in motions and interaction. In this part, we move quickly from shaping up visual elements in static to animate and scale them in variants and complexity. We also make the comparatively large step to interaction as input for animating visual elements already in this first step. This allows creatives to directly experience the power and expressivity of a computational creative tool like Processing. We don’t hold back in this first step, because we see interaction (and ultimately data) as the important differentiator and driver behind the power of computational in creative practice. Even the raw understanding of interaction in code can help creatives ideate with minimal computation at an early stage of a project.Chapter 2: Composition and StructureIn this chapter, we align the structure of code and the visual structure to reinforce the initial momentum with transparent concepts in code. In this step, we list different code examples that are related to repetition and variation. These are all features related to the creation and manipulation of a Gestalt, introduced as the “many things as one” concept in the book. The reader learns about the shift from an individual element in repetition to many things in layers and alignment. While we introduce fewer new elements from Processing, we maintain the momentum for the reader in showing how they can, with a few lines of code, amplify the expressivity of their first tryouts. The divergence from traditional creative programming books is most visible in the second step, we leave the path of explaining Processing and let the creative process take charge.Chapter 3: Refinement and DepthIn this chapter, we use randomness and noise as sources for depth and entropy and explain how to refine and deepen the idea regarding controlling, selecting, and making choices. In this part, we specifically introduce new data structures as means to simplify and extend the design of aesthetics, rhythms and smoothness. We also return to interactivity at this developed stage and use interactivity as input to bring creative concepts closer to refinement and depth. Chapter 4: Completion and ProductionIn this chapter, we look at the backstage of coding an art piece for presentation and “show-time”. We show how to leverage the diversity of art code on other platforms like the web or in mobile applications. In this step, we also specify how to backstage, test and control the creative work in a less risky way on the final production stage.Part II: An Example: MOUNTROTHKOIn the second part of this book, we present a large example for computational art, MOUNTROTHKO (2018). This part shows how we applied many aspects of the first part of the book in a real project. We emphasize that what we write about in this book is what we also practice: we unfold MOUNTROTHKO from the very beginning by showing the conceptual and visual starting points. Then we walk through the four steps of the whole creative process in close relation to this example. In MOUNTROTHKO, certain steps were taken going back and forth, or in iteration, which underlines how the book is practically meaningful as a process reference.Chapter 5: InspirationChapter 6: From idea to completionPart III: Coding PracticeIn the last part of this book, we address common pitfalls and challenges of the creative process and formulate suggestions and tips for creatives based on our experience over the years. We indicate main problems that creatives might have in practice: how to help yourself, how to get help from others, and how to find and work with experts from other fields. Finally, we outline a continuation of the learning path for creatives alongside reading and making: this book ideally represents the starting of a personal creative journey working with both art and code.Chapter 7: Dealing with Problems Chapter 8: Learning PathChapter 9: Creative ProcessesConclusionEpilogue

Read more less

Book SynopsisDive into the diverse facets of the Laravel ecosystem. This comprehensive guide will put you on the fast track to becoming an expert in Laravel development. Starting with the fundamentals, you'll explore essential concepts, enabling you to grasp the framework's structure. Subsequent chapters cover intricate topics, such as advanced routing techniques, database management, and eloquent object relational mapping (ORM), allowing developers to build robust applications. The book offers comprehensive insights into building secure applications with authentication and authorization mechanisms, as well as constructing efficient APIs and employing caching techniques for enhanced performance. Chapters on real-time applications and queues offer practical knowledge to optimize application responsiveness. Advanced package development and performance monitoring provide valuable tools for developing high-quality Laravel packages and debugging. You'll also gain expertise in internationalization, frontTable of ContentsChapter 1: Understanding the Laravel Ecosystem.- Chapter 2: Advanced Routing Techniques.- Chapter 3: Database Management and Eloquent ORM.- Chapter 4: Authentication and Authorization.- Chapter 5: Building APIs with Laravel.- Chapter 6: Caching and Performance Optimization.- Chapter 7: Advanced Middleware Techniques.- Chapter 8: Real-Time Applications with Laravel.- Chapter 9: Testing and Test-Driven Development.- Chapter 10: Queues and Job Scheduling.- Chapter 11: Advanced Package Development.-Chapter 12: Performance Monitoring and Debugging.- Chapter 13: Scaling Laravel Applications.- Chapter 14: Security Best Practices.- Chapter 15: Advanced Performance Optimization.- Chapter 16: Continuous Integration and Deployment.- Chapter 17: Laravel and Microservices.- Chapter 18: Advanced Laravel Debugging and Troubleshooting.-Chapter 19: Building Internationalized Applications with Laravel.- Chapter 20: Advanced Frontend Development with Laravel.- Chapter 21: Advanced Error Handling and Exception Management.- Chapter 22: Advanced Database Techniques and Optimization.- Chapter 23: Laravel and Serverless Computing.- Chapter 24: Building Progressive Web Applications (PWAs) with Laravel.- Chapter 25: Advanced UI/UX Design Patterns for Laravel.- Chapter 26: Advanced Analytics and Reporting in Laravel.- Chapter 27: Building Microservices with Laravel and Docker.- Chapter 28: Advanced Third-Party Integrations.- Chapter 29: Securing Laravel Applications.- Chapter 30: Advanced DevOps and Infrastructure Automation Appendix A: Laravel Cheat Sheet .- Appendix B: Recommended Resources.- Appendix C: Glossary of Terms

Read more less

Book SynopsisDo you dream of learning React without spending months in endless tutorials? Then this book is for you! In just five days, you will acquire the fundamental skills to start developing exceptional applications using this revolutionary technology.Whether you prefer to follow the book independently or alongside other online resources, it will provide you with a solid foundation to harness the full potential of React. Immerse yourself in an accelerated learning method that will allow you to make giant strides. Chapters are carefully designed to teach you the essential concepts of React, such as components, props, state, events, lifecycle, and hooks, without wasting time on complex explanations. Thanks to a clear and accessible writing style, you'll be able to dive into the intricacies of React from the first page. Code examples are accompanied by detailed explanations, enabling you to quickly grasp the subtleties of this technology. You don't need to be an expert in programming; the book isTable of Contents

Read more less

Book SynopsisHow can you take advantage of the HipHop Virtual Machine (HHVM) and the Hack programming language, two new technologies that Facebook developed to run their web servers? With this practical guide, Owen Yamauchi-a member of Facebook's core Hack and HHVM teams-shows you how to get started with these battle-tested open-source tools.

Read more less

Book SynopsisIn today's fast and competitive world, a program's performance is just as important to customers as the features it provides. This practical guide teaches developers performance-tuning principles that enable optimization in C++.

Read more less

Book SynopsisThis practical guide shows hardware and software engineers, makers, and web developers how to talk in JavaScript with a variety of hardware platforms. Authors Patrick Mulder and Kelsey Breseman also delve into the basics of microcontrollers, single-board computers, and other hardware components.

Read more less

Book SynopsisThis concise guide helps busy IT professionals get up and running quickly with this popular data interchange format, and provides a deep understanding of how JSON works. Author Lindsay Bassett begins with an overview of JSON syntax, data types, formatting, and security concerns before exploring the many ways you can apply JSON today.

Read more less

Book SynopsisWith this practical book, data scientists and professionals working with large-scale data applications will learn how to use Spark from R to tackle big data and big compute problems.

Read more less

Book SynopsisJumpstarting books provide an avenue for makers to quickly master topical knowledge! Each book starts with instructions on how to install or initialize the hardware or software needed to reach the "Hello, World" stage of getting started! The second project in the book builds on the first to use more of the hardware or software's capabilities. Later projects expand the user's knowledge into lesser-known aspects of the topic. All Jumpstarting projects are for Makers -- they provide hands-on, real-world experience in making the hardware or software do what you want it to do!

Read more less

Book SynopsisLearn the basics of using the micro: bit, an open source hardware ARM-based embedded system used to teach computer programming, to build a series of 10 different gadgets from scratch! You'll use the micro: bit to make: a scrolling name tag, animated LED displays a high-tech compass. a handheld tilting game with a buzzer and saved high score a carnival-like strength tester a powered cooling fan helmet an electronic musical instrument a security system that sends alerts to your computer when someone enters the room. a wheeled robot an alert to water your plants You will learn how simple electrical devices like speakers, motors, buzzers and fans work. You'll understand electronic components like resistors, force resistors, photoresistors, LEDs, and Op Amps, as well as Infrared distance sensors and soil moisture sensors. You'll also get a beginner's look at micropython, one of the fastest-growing computer languages. In this book you will combine multiple disciplines -- electronics, programming, and engineering -- to build a series of successful gadgets. Everything is explained with lots and lots of full-color line drawings. No prior experience is necessary. You'll have fun while you learn a t

Read more less

Book SynopsisFormal Languages, Automaton and Numeration Systems presents readers with a review of research related to formal language theory, combinatorics on words or numeration systems, such as Words, DLT (Developments in Language Theory), ICALP, MFCS (Mathematical Foundation of Computer Science), Mons Theoretical Computer Science Days, Numeration, CANT (Combinatorics, Automata and Number Theory). Combinatorics on words deals with problems that can be stated in a non-commutative monoid, such as subword complexity of finite or infinite words, construction and properties of infinite words, unavoidable regularities or patterns. When considering some numeration systems, any integer can be represented as a finite word over an alphabet of digits. This simple observation leads to the study of the relationship between the arithmetical properties of the integers and the syntactical properties of the corresponding representations. One of the most profound results in this direction is given by the celebrated theorem by Cobham. Surprisingly, a recent extension of this result to complex numbers led to the famous Four Exponentials Conjecture. This is just one example of the fruitful relationship between formal language theory (including the theory of automata) and number theory.Trade Review"This nice book is devoted to a quickly growing field, at the frontier between theoretical computer science, combinatorics, and number theory." (Zentralblatt MATH, 2016)Table of ContentsFOREWORD ix INTRODUCTION xiii CHAPTER 1. WORDS AND SEQUENCES FROM SCRATCH 1 1.1. Mathematical background and notation 2 1.1.1. About asymptotics 4 1.1.2. Algebraic number theory 5 1.2. Structures, words and languages 11 1.2.1. Distance and topology 16 1.2.2. Formal series 24 1.2.3. Language, factor and frequency 28 1.2.4. Period and factor complexity 33 1.3. Examples of infinite words 36 1.3.1. About cellular automata 43 1.3.2. Links with symbolic dynamical systems 46 1.3.3. Shift and orbit closure 59 1.3.4. First encounter with β-expansions 62 1.3.5. Continued fractions 69 1.3.6. Direct product, block coding and exercises 70 1.4. Bibliographic notes and comments 77 CHAPTER 2. MORPHIC WORDS 85 2.1. Formal definitions 89 2.2. Parikh vectors and matrices associated with a morphism 96 2.2.1. The matrix associated with a morphism 98 2.2.2. The tribonacci word 99 2.3. Constant-length morphisms 107 2.3.1. Closure properties 117 2.3.2. Kernel of a sequence 119 2.3.3. Connections with cellular automata 120 2.4. Primitive morphisms 122 2.4.1. Asymptotic behavior 127 2.4.2. Frequencies and occurrences of factors 127 2.5. Arbitrary morphisms 133 2.5.1. Irreducible matrices 134 2.5.2. Cyclic structure of irreducible matrices 144 2.5.3. Proof of theorem 2.35 150 2.6. Factor complexity and Sturmian words 153 2.7. Exercises 159 2.8. Bibliographic notes and comments 163 CHAPTER 3. MORE MATERIAL ON INFINITE WORDS 173 3.1. Getting rid of erasing morphisms 174 3.2. Recurrence 185 3.3. More examples of infinite words 191 3.4. Factor Graphs and special factors 202 3.4.1. de Bruijn graphs 202 3.4.2. Rauzy graphs 206 3.5. From the Thue–Morse word to pattern avoidance 219 3.6. Other combinatorial complexity measures 228 3.6.1. Abelian complexity 228 3.6.2. k-Abelian complexity 237 3.6.3. k-Binomial complexity 245 3.6.4. Arithmetical complexity 249 3.6.5. Pattern complexity 251 3.7. Bibliographic notes and comments 252 BIBLIOGRAPHY 257 INDEX 295 SUMMARY OF VOLUME 2 303

Read more less

Book SynopsisThe purpose of this book is to provide an introduction to this set of technologies to teach a new programmer how to get started creating data-driven websites and to provide a jumping-off point for the reader to expand his or her skills. Today's modern world is heavily dependent on the World Wide Web. It affects the way we communicate, how we shop, and how we learn about the world. Every website, every page, consists of four fundamental elements: the structure, the style, the programming, and the data. These correspond to four different "languages," respectively: HTML, CSS, PHP, and MySQL. After learning the necessary components, users will have the understanding required to use the above technologies to create a working website. This book is aimed at the programmer or student who understands the basic building blocks of programming such as statements and control structures but lacks knowledge of the syntax and application of the above-mentioned technologies.

Read more less

Book SynopsisAgda is an advanced programming language based on Type Theory. Agda's type system is expressive enough to support full functional verification of programs, in two styles. In external verification, we write pure functional programs and then write proofs of properties about them. The proofs are separate external artifacts, typically using structural induction. In internal verification, we specify properties of programs through rich types for the programs themselves. This often necessitates including proofs inside code, to show the type checker that the specified properties hold. The power to prove properties of programs in these two styles is a profound addition to the practice of programming, giving programmers the power to guarantee the absence of bugs, and thus improve the quality of software more than previously possible.Verified Functional Programming in Agda is the first book to provide a systematic exposition of external and internal verification in Agda, suitable for undergraduate students of Computer Science. No familiarity with functional programming or computer-checked proofs is presupposed.The book begins with an introduction to functional programming through familiar examples like booleans, natural numbers, and lists, and techniques for external verification. Internal verification is considered through the examples of vectors, binary search trees, and Braun trees. More advanced material on type-level computation, explicit reasoning about termination, and normalization by evaluation is also included. The book also includes a medium-sized case study on Huffman encoding and decoding.

Read more less

Book SynopsisAgda is an advanced programming language based on Type Theory. Agda's type system is expressive enough to support full functional verification of programs, in two styles. In external verification, we write pure functional programs and then write proofs of properties about them. The proofs are separate external artifacts, typically using structural induction. In internal verification, we specify properties of programs through rich types for the programs themselves. This often necessitates including proofs inside code, to show the type checker that the specified properties hold. The power to prove properties of programs in these two styles is a profound addition to the practice of programming, giving programmers the power to guarantee the absence of bugs, and thus improve the quality of software more than previously possible.Verified Functional Programming in Agda is the first book to provide a systematic exposition of external and internal verification in Agda, suitable for undergraduate students of Computer Science. No familiarity with functional programming or computer-checked proofs is presupposed.The book begins with an introduction to functional programming through familiar examples like booleans, natural numbers, and lists, and techniques for external verification. Internal verification is considered through the examples of vectors, binary search trees, and Braun trees. More advanced material on type-level computation, explicit reasoning about termination, and normalization by evaluation is also included. The book also includes a medium-sized case study on Huffman encoding and decoding.

Read more less