Programmierung
Einstieg in C# mit Visual Studio 2022
Ideal für ProgrammiereinsteigerC#-Programmierung leicht gemacht! An einfach nachvollziehbaren Beispielen lernen Sie alle wichtigen Themen rund um die Programmierung mit C#. Thomas Theis ist spezialisiert darauf, gerade Anfängern einen guten Einstieg zu ermöglichen. Das gelingt ihm dank anschaulicher Beispiele und klar verständlicher Sprache. Dieses Buch führt Sie von der Installation von Visual Studio 2022 zu den Sprachgrundlagen und stellt Ihnen objektorientierte Programmierung, Fehlerbehandlung, das Erstellen von Datenbankanwendungen sowie die Entwicklung von GUIs einsteigergerecht vor.Aus dem Inhalt:Einführung in Visual Studio 2022C#-SprachgrundlagenObjektorientiert programmierenGUIs entwickelnProgrammieren mit der WPFDatenbankanwendungenZeichnen mit GDI+Leseprobe (PDF)Autor:Thomas Theis, Dipl.-Ing. für Technische Informatik, verfügt über langjährige Erfahrung als EDV-Dozent, unter anderem an der Fachhochschule Aachen.
Clean ABAP
Schluss mit unleserlichen ABAP-Programmen! Dieses offizielle Begleitbuch zum Repository »Clean ABAP« auf GitHub zeigt Ihnen, wie Sie intuitiv verständlichen und leicht zu wartenden Code schreiben. Gespickt mit Best Practices zu Namenskonventionen, Kommentaren und Formatierungen, ist dieser Leitfaden unverzichtbar für den Programmieralltag. Aus dem Inhalt: Klassen und InterfacesMethodenNamen von ObjektenVariablen und LiteraleInterne TabellenKontrollflussKommentareFormatierungFehlerbehandlungUnit-TestsPaketeClean ABAP im Team umsetzen Einleitung ... 17 1. Einführung ... 23 1.1 ... Was ist Clean ABAP? ... 23 1.2 ... Wie kann ich mit Clean ABAP anfangen? ... 26 1.3 ... Wie gehe ich mit Legacy-Code um? ... 28 1.4 ... Wie kann ich Code automatisch prüfen? ... 30 1.5 ... Wie steht Clean ABAP im Verhältnis zu anderen Programmierleitfäden? ... 32 1.6 ... Wie kann ich mich in der Clean-ABAP-Community engagieren? ... 33 1.7 ... Zusammenfassung ... 34 2. Die Programmiersprache ABAP ... 35 2.1 ... Legacy-Code ... 35 2.2 ... Performance ... 38 2.3 ... Objektorientierte vs. prozedurale Programmierung ... 41 2.4 ... Funktionale vs. prozedurale Sprachkonstrukte ... 49 2.5 ... Obsolete Sprachelemente ... 52 2.6 ... Entwurfsmuster ... 54 2.7 ... Zusammenfassung ... 56 3. Klassen und Interfaces ... 59 3.1 ... Objektorientierung ... 59 3.2 ... Geltungsbereich und Sichtbarkeit ... 90 3.3 ... Konstruktoren ... 99 3.4 ... Zusammenfassung ... 111 4. Methoden ... 113 4.1 ... Objektorientierte Programmierung ... 113 4.2 ... Parameter ... 121 4.3 ... Methodeninhalt ... 137 4.4 ... Methoden aufrufen ... 148 4.5 ... Zusammenfassung ... 153 5. Namen ... 155 5.1 ... Gute Namen ... 155 5.2 ... Eigenheiten von ABAP ... 162 5.3 ... Affixe: Präfixe, Suffixe und Infixe ... 163 5.4 ... Mit Legacy-Code umgehen ... 166 5.5 ... Zusammenfassung ... 167 6. Variablen und Literale ... 169 6.1 ... Variablen ... 170 6.2 ... Konstanten ... 177 6.3 ... Zeichenketten ... 186 6.4 ... Boolesche Ausdrücke ... 188 6.5 ... Reguläre Ausdrücke ... 191 6.6 ... Das Schlüsselwort REDUCE ... 193 6.7 ... Zusammenfassung ... 196 7. Interne Tabellen ... 197 7.1 ... Die richtige Tabellenart verwenden ... 198 7.2 ... DEFAULT KEY vermeiden ... 200 7.3 ... Zeilen hinzufügen mit INSERT INTO TABLE und APPEND TO ... 201 7.4 ... Prüfen, ob eine Tabelle eine bestimmte Zeile enthält ... 202 7.5 ... Tabelleninhalte abfragen ... 204 7.6 ... Die Anweisung LOOP AT ... WHERE ... und verschachtelte IF-Anweisungen ... 206 7.7 ... Unnötige Tabellenabfragen identifizieren ... 207 7.8 ... Tabellenzeilen blockweise und Zeile für Zeile bearbeiten ... 208 7.9 ... DESCRIBE TABLE und die Funktion LINES ... 209 7.10 ... Zusammenfassung ... 210 8. Kontrollfluss ... 211 8.1 ... Das Schlüsselwort IF ... 212 8.2 ... Schachtelungstiefe ... 217 8.3 ... Bedingungen ... 218 8.4 ... Das Schlüsselwort CASE ... 225 8.5 ... Die Anweisung DO 1 TIMES ... 229 8.6 ... Zusammenfassung ... 233 9. Kommentare ... 235 9.1 ... Präziser Code benötigt keine Kommentare ... 235 9.2 ... Kommentare richtig platzieren und verwenden ... 238 9.3 ... Kommentare, die Sie vermeiden sollten ... 239 9.4 ... FIXME-, TODO- und XXX-Kommentare ... 242 9.5 ... Spezielle Kommentare: ABAP Doc, Pragmas und Pseudokommentare ... 244 9.6 ... Zusammenfassung ... 245 10. Formatierung ... 247 10.1 ... Einen konsistenten Stil verfolgen ... 248 10.2 ... Den Code fürs Lesen optimieren ... 249 10.3 ... Der Pretty Printer ... 250 10.4 ... Wie viele Anweisungen pro Zeile? ... 252 10.5 ... Zeilenlänge ... 252 10.6 ... Code straffen ... 254 10.7 ... Leerzeilen ... 255 10.8 ... Zuweisungen ausrichten ... 256 10.9 ... Variablendeklarationen ausrichten ... 257 10.10 ... Wohin mit den Klammern? ... 257 10.11 ... Methodenparameter formatieren ... 258 10.12 ... Zusammenfassung ... 263 11. Fehlerbehandlung ... 265 11.1 ... Nachrichten ... 265 11.2 ... Rückgabewerte ... 269 11.3 ... Ausnahmen ... 274 11.4 ... Ausnahmen auslösen und behandeln ... 284 11.5 ... Zusammenfassung ... 291 12. Unit Tests ... 293 12.1 ... Testklassen ... 294 12.2 ... Testmethoden ... 304 12.3 ... Die getestete Klasse ... 309 12.4 ... Namen von Testklassen und -methoden ... 310 12.5 ... Assertions ... 313 12.6 ... Test-Doubles ... 325 12.7 ... Test-Seams ... 337 12.8 ... Konzepte zum Umgang mit Unit Tests ... 339 12.9 ... Zusammenfassung ... 343 13. Pakete ... 345 13.1 ... Allgemeine Paketkonzepte ... 345 13.2 ... Paketkonzept in ABAP ... 347 13.3 ... Optionen für das Paketdesign ... 353 13.4 ... Paketprüfungen ... 358 13.5 ... Konsequenzen einer mangelhaften oder fehlenden Paketstrategie ... 367 13.6 ... Zusammenfassung ... 368 14. Wie Sie Clean ABAP umsetzen ... 369 14.1 ... Gemeinsames Verständnis der Teammitglieder ... 370 14.2 ... Den Broken-Window-Effekt angehen ... 374 14.3 ... Code-Reviews und Lernen ... 378 14.4 ... Clean Code Advisor ... 382 14.5 ... Lerntechniken ... 382 14.6 ... Continuous Learning in funktionsübergreifenden Teams ... 387 14.7 ... Zusammenfassung ... 390 Das Autorenteam ... 391 Index ... 393
Beginning ReactJS Foundations Building User Interfaces with ReactJS
QUICKLY LEARN THE MOST WIDELY USED FRONT-END DEVELOPMENT LANGUAGE WITH EASE AND CONFIDENCEReact JS Foundations: Building User Interfaces with ReactJS - An Approachable Guide walks readers through the fundamental concepts of programming with the explosively popular front-end tool known as React JS. Written by an accomplished full-stack engineer, speaker, and community organizer, React JS Foundations teaches readers how to understand React and how to begin building applications with it. The book:* Explains and clarifies technical terminology with relevant and modern examples to assist people new to programming understand the language* Helps experienced programmers quickly get up to speed with React* Is stocked throughout with practical and applicable examples of day-to-day React workPerfect for beginner, intermediate, and advanced programmers alike, React JS Foundations will quickly bring you up to speed on one of the most useful and widely used front-end languages on the web today. You can start building your first application today. ABOUT THE AUTHORCHRIS MINNICK is an accomplished author, trainer, and web developer with experience working on web and mobile projects with both small and large companies. The companion website at www.reactjsfoundations.com provides code listings for each chapter, plus examples and downloads that can be used to test out the various ReactJS techniques in the book. Introduction XxviiCHAPTER 1: HELLO, WORLD! 1React without a Build Toolchain 1Interactive “Hello, World” with Create React App and JSX 7Summary 9CHAPTER 2: THE FOUNDATION OF REACT 11What’s in a Name? 11UI Layer 12Virtual DOM 13The Philosophy of React 14Thinking in Components 15Composition vs. Inheritance 15React Is Declarative 16React Is Idiomatic 17Why Learn React? 17React vs.... 18React vs. Angular 18React vs. Vue 19What React Is Not 19React Is Not a Web Server 20React Is Not a Programming Language 20React Is Not a Database Server 21React Is Not a Development Environment 21React Is Not the Perfect Solution to Every Problem 21Summary 21CHAPTER 3: JSX 23JSX Is Not HTML 23What Is JSX? 30How JSX Works 30Transpiler . . . Huh? 31Compilation vs. Transpilation 31JSX Transform 31Introducing Babel 31Eliminating Browser Incompatibilities 33Syntax Basics of JSX 33JSX Is JavaScript XML 33Beware of Reserved Words 33JSX Uses camelCase 33Preface Custom Attributes in DOM Elements with data-34JSX Boolean Attributes 34Use Curly Braces to Include Literal JavaScript 35Remember to Use Double Curly Braces with Objects 35Put Comments in Curly Braces 35When to Use JavaScript in JSX 36Conditionals in JSX 36Conditional Rendering with if/else and Element Variables 36Conditional Rendering with the && Operator 37Conditional Rendering with the Conditional Operator 38Expressions in JSX 38Using Children in JSX 40React Fragments 40Summary 41CHAPTER 4: ALL ABOUT COMPONENTS 43What Is a Component? 43Components vs. Elements 44Components Define Elements 44Elements Invoke Components 45Built-in Components 47HTML Element Components 47Attributes vs. Props 52Passing Props 52Accessing Props 52Standard HTML Attributes 54Non-Standard Attributes 56Custom Attributes 56User-DefinedComponents 56Types of Components 56Class Components 57Stepping through a React Class Component 68React.Component 68Importing React.Component 68The Class Header 69The Constructor Function 69Managing State in Class Components 71The Render Function 73Creating and Using Props 74Function Components 76What Are Function Components? 79How to Write Function Components 79Optimizations and Function Component Shortcuts 80Managing State in Function Components 83Differences between Function and Class Components 84React Component Children 84this.props.children 85Manipulating Children 86React.Children 86isValidElement 87cloneElement 87The Component Lifecycle 89Mounting 90constructor() 90static getDerivedStateFromProps 90render 90componentDidMount() 90Updating 90shouldComponentUpdate 91getSnapshotBeforeUpdate 91componentDidUpdate 92Unmounting 92componentWillUnmount 92Error Handling 92getDerivedStateFromError 92componentDidCatch 92Improving Performance and Avoiding Errors 92Avoiding Memory Leaks 93React.PureComponent 96React.memo 97React.StrictMode 98Rendering Components 98Rendering with ReactDOM 98Virtual DOM 100Other Rendering Engines 101React Native 101ReactDOMServer 102React Konsul 103react-pdf 103Component Terminology 103Summary 104CHAPTER 5: REACT DEVTOOLS 105Installation and Getting Started 105Inspecting Components 107Working with the Component Tree 108Searching for Components 110Using the Search Input Box 110Using Regular Expressions 110Filtering Components 112Selecting Components 114Editing Component Data in DevTools 114Working with Additional DevTools Functionality 118Profiling 119Summary 121CHAPTER 6: REACT DATA FLOW 123One-WayData Flow 123Understanding One-WayData Flow 124Why One-WayData Flow? 125Props 126Components Receive Props 126Props Can Be Any Data Type 126Props Are Read-Only 127Validating Incoming Props with PropTypes 129What Is PropTypes? 130Getting Started with PropTypes 131What Can PropTypes Validate? 133Default Props 141React State 145What Is state? 146Initializing state 146Initializing state in Class Components 146Initializing State in Function Components 147The Difference between state and props 149Updating state 149Updating a Class Component’s state with setState 150Updating state with Function Components 154What to Put in State 161Building the Reminders App 161What Not to Put in State 168Where to Put State 168Lifting State Up 170About the key Prop 177Filtering the Reminders 183Implementing the isComplete Changing Functionality 188Converting to Class Components 190Summary 198CHAPTER 7: EVENTS 199How Events Work in React 199What Is SyntheticEvent? 201Using Event Listener Attributes 202The Event Object 203Supported Events 204Event Handler Functions 211Writing Inline Event Handlers 211Writing Event Handlers in Function Components 212Writing Event Handlers in Class Components 213Binding Event Handler Functions 214Using bind 215Using Arrow Functions 216Passing Data to Event Handlers 218Summary 219CHAPTER 8: FORMS 221Forms Have State 221Controlled Inputs vs. Uncontrolled Inputs 222Updating a Controlled Input 223Controlling an Input in a Function Component 224Controlling an Input in a Class Component 224Lifting Up Input State 226Using Uncontrolled Inputs 228Using Different Form Elements 229Controlling the Input Element 230Controlling a textarea 230Controlling a Select Element 231Preventing Default Actions 231Summary 232CHAPTER 9: REFS 233What Refs Are 233How to Create a Ref in a Class Component 234How to Create a Ref in a Function Component 234Using Refs 234Creating a Callback Ref 236When to Use Refs 238When Not to Use Refs 238Examples 239Managing Focus 239Automatically Selecting Text 239Controlling Media Playback 241Setting Scroll Position 241Summary 242CHAPTER 10: STYLING REACT 243The Importance of Styles 243Importing CSS into the HTML File 244Using Plain Old CSS in Components 245Writing Inline Styles 247JavaScript Style Syntax 248Why to Use Inline Styles 249Why Not to Use Inline Styles 249Improving Inline Styles with Style Modules 249CSS Modules 250Naming CSS Module Files 251Advanced CSS Modules Functionality 252Global Classes 252Class Composition 252CSS-in- JS and Styled Components 253Summary 255CHAPTER 11: INTRODUCING HOOKS 257What Are Hooks? 257Why Were Hooks Introduced? 257Rules of Hooks 259The Built-in Hooks 259Managing State with useState 260Setting the Initial State 262Using the Setter Function 262Passing a Value to a Setter 263Passing a Function to a Setter 263Setter Function Value Comparison 264Hooking into the Lifecycle with useEffect 264Using the Default useEffect Behavior 265Cleaning Up After Effects 265Customizing useEffect 266Running Asynchronous Code with useEffect 270Subscribing to Global Data with useContext 272Combining Logic and State with useReducer 273Memoized Callbacks with useCallback 275Caching Computed Values with useMemo 278Solving Unnecessary Renders 278Solving Performance Problems 279Accessing Children Imperatively with useRef 279Customizing Exposed Values with useImperativeHandle 280Updating the DOM Synchronously with useLayoutEffect 281Writing Custom Hooks 281Labeling Custom Hooks with useDebugValue 283Finding and Using Custom Hooks 285use-http 285react-fetch-hook 286axios-hooks 286react-hook- form 286@rehooks/local-storage 287use-local- storage- state 287Other Fun Hooks 288Lists of Hooks 288Summary 288CHAPTER 12: ROUTING 289What Is Routing? 289How Routing Works in React 291Using React Router 293Installing and Importing react-router- dom 293The Router Component 294Selecting a Router 294Using the Router Component 295Linking to Routes 296Internal Linking with Link 296Internal Navigation with NavLink 298Automatic Linking with Redirect 302Creating Routes 302Restricting Path Matching 304Using URL Parameters 304The component Prop 305Render Props 306Switching Routes 307Rendering a Default Route 308Routing with Redirect 308Behind the Scenes: location, history, and match 309The history Object 310The location Object 313The match Object 313React Router Hooks 317useHistory 317useLocation 317useParams 317useRouteMatch 317Summary 318CHAPTER 13: ERROR BOUNDARIES 319The Best Laid Plans 319What Is an Error Boundary? 320Implementing an Error Boundary 323Building Your Own ErrorBoundary Component 323getDerivedStateFromErrors Is a Static Method 324getDerivedStateFromErrors Runs During the Render Phase 325getDerivedStateFromErrors Receives the Error as a Parameter 325getDerivedStateFromErrors Should Return an Object for Updating State 325Testing Your Boundary 326Logging Errors with ComponentDidCatch() 327Using a Logging Service 328Resetting the State 333Installing a Pre-Built ErrorBoundary Component 334What Can’t an Error Boundary Catch? 336Catching Errors in Error Boundaries with try/catch 336Catching Errors in Event Handlers with react-error- boundary 337Summary 338CHAPTER 14: DEPLOYING REACT 339What Is Deployment? 339Building an App 339Running the build Script 340Examining the build Directory 340The Built index.html 341The static Directory 342asset-manifest. json 342What’s in a Name? 343How Is a Deployed App Different? 343Development Mode vs. Production 343Putting It on the Web 344Web Server Hosting 344Node Hosting 345Deploying with Netlify 345Enabling Routing with Netlify 347Enabling Custom Domains and HTTPS 348Summary 349CHAPTER 15: INITIALIZE A REACT PROJECT FROM SCRATCH 351Building Your Own Toolchain 351Initializing Your Project 352The HTML Document 352The Main JavaScript File 353The Root Component 353Running in the Browser 354How Webpack Works 357Loaders 358Plugins 358Automating Your Build Process 358Making an HTML Template 359Development Server and Hot Reloading 360Testing Tools 360Installing and Configuring ESLint 360ESLint Configuration 361How to Fix Errors 362Testing with Jest 363Creating NPM Scripts 364Structuring Your Source Directory 365Grouping by File Type 366Grouping by Features 367Summary 367CHAPTER 16: FETCHING AND CACHING DATA 369Asynchronous Code: It’s All About Timing 369JavaScript Never Sleeps 370Where to Run Async Code in React 374Ways to Fetch 376Getting Data with Fetch 377Getting Data with Axios 377Using Web Storage 379Two Types of Web Storage 379When to Use Web Storage 380When Not to Use Web Storage 380Web Storage Is Synchronous 380Working with localStorage 381Storing Data with localStorage 381Reading Data from localStorage 382Removing Data from localStorage 384Summary 385CHAPTER 17: CONTEXT API 387What Is Prop Drilling? 387How Context API Solves the Problem 388Creating a Context 388Creating a Provider 389Consuming a Context 390Using Context in a Class Component 390Using Context in a Function Component 391Common Use Cases for Context 391When Not to Use Context 392Composition as an Alternative to Context 392Example App: User Preferences 396Summary 398CHAPTER 18: REACT PORTALS 399What Is a Portal? 399How to Make a Portal 399Why Not Just Render Multiple Component Trees? 403Common Use Cases 403Rendering and Interacting with a Modal Dialog 404Managing Keyboard Focus with Modals 409Summary 411CHAPTER 19: ACCESSIBILITY IN REACT 413Why Is Accessibility Important? 413Accessibility Basics 414Web Content Accessibility Guidelines (WCAG) 414Web Accessibility Initiative –Accessible Rich Internet Applications (WAI-ARIA) 415Implementing Accessibility in React Components 415ARIA Attributes in React 416Semantic HTML 416Form Accessibility 417Focus Control in React 418Skip Links 418Managing Focus Programmatically 419Media Queries in React 420Media Queries in Included CSS 421Using useMediaQuery 422Summary 422CHAPTER 20: GOING FURTHER 425Testing 425Mocha 426Enzyme 426Chai 427Assert 427Expect 428Should 428Karma 428Nightwatch.js 428Server-SideRendering 429Flux 430Redux 430GraphQL 432Apollo 433React Native 434Next.js 434Gatsby 434People to Follow 435Useful Links and Resources 435Summary 436Index 437
Der Weg zum Python-Profi
Ein Best-Practice-Buch für sauberes Programmieren. Der Brückenschlag zu einer anderen Ebene der Python-Programmierung.Sie haben ein grundlegendes Python-Programmiertutorial absolviert oder bereits erste Erfahrungen im Programmieren. Was ist der nächste Schritt auf dem Weg zur fähigen, kompetenten Softwareentwickler:in? Der Weg zum Python Profi ist mehr als eine bloße Sammlung meisterhafter Tipps für das Schreiben von sauberem Code. Es zeigt Ihnen, wie Sie die Kommandozeile bedienen und andere professionelle Tools wie Code-Formatierer, Type Checkers, Linters und Versionskontrolle verwenden können. Al Sweigart führt Sie durch bewährte Praktiken für die Einrichtung Ihrer Entwicklungsumgebung, die Benennung von Variablen und die Verbesserung der Lesbarkeit und geht dann auf Dokumentation, Organisation, Leistungsmessung, objektorientiertes Design und sogar Big-O-Algorithmus-Analyse ein. Die Hinweise und Anleitungen des Buchs werden Ihre Programmierfähigkeiten deutlich verbessern - nicht nur in Python, sondern in jeder Sprache.Sie werden lernen:wie Sie Pythons automatisches Formatierungswerkzeug Black für sauberen Code verwendenwie Sie häufige Fehlerquellen erkennen und sie mit Static analyzers aufspürenwie Sie die Dateien in Ihren Code-Projekten mit dem Cookiecutter-Template-Tool strukturierenerschließen Sie sich funktionale Programmiertechniken wie Lambda- und Funktionen höherer Ordnungwie Sie die Geschwindigkeit Ihres Codes mit den in Python integrierten Modulen timeit und cProfile verbessern könnenwie Sie Ihre Kommentare und Dokumentationsstrings informativ gestalten und wie oft Sie sie schreiben solltenAutor: Al Sweigart arbeitet als Softwareentwickler und bringt Jugendlichen und Erwachsenen das Programmieren bei. Er ist Autor mehrerer Bücher für Einsteiger, u.a. „Eigene Spiele programmieren mit Python“.
C++ Software Interoperability for Windows Programmers
Get up-to-speed quickly and connect modern code written in C#, R, and Python to an existing codebase written in C++. This book for practitioners is about software interoperability in a Windows environment from C++ to languages such as C#, R, and Python. Using a series of example projects, the book demonstrates how to connect a simple C++ codebase packaged as a static or dynamic library to modern clients written in C#, R, and Python. The book shows you how to develop the in-between components that allow disparate languages to communicate.This book addresses a fundamental question in software design: given an existing C++ codebase, how does one go about connecting that codebase to clients written in C#, R, and Python? How is the C++ functionality exposed to these clients? One answer may be to rewrite the existing codebase in the target language. This is rarely, if ever, feasible and this book’s goal is to save you the pain and the high cost of throwing out valuable existing code by showing you how to make that older code function alongside and with the more modern languages that are commonly in use today. The knowledge you will gain from reading this book will help you broaden your architectural choices and take advantage of the growing amount of talent around newer languages.WHAT YOU WILL LEARN* Build components that connect C++ to other languages* Translate between the C++ type system and the type systems of C#, R, and Python* Write a managed assembly targeting the .NET framework* Create C++ packages for use in R/Studio* Develop Python modules based on high-performance C++ code* Overcome the difficulties and pitfalls involved in cross-language developmentWHO THIS BOOK IS FORSoftware developers who are looking for ways to extend existing systems written in C++ using modern languages. Readers should have some programming experience, particularly in C++. Readers should also be familiar with common development tools such as Visual Studio, R/Studio, Visual Studio Code, and CodeBlocks.ADAM GLADSTONE is a software developer with more than 20 years of experience in investment banking, building software mostly in C++ and C#. For the last few years, he has been developing data science and machine learning skills, particularly in Python and R after completing a degree in Math & Statistics. He currently works at Virtu Financial Inc. in Madrid as an Analyst Programmer. In his free time, he develops tools for natural language processing.IntroductionPART I. C++1. Preliminaries2. C++ Components and C++ ClientsPART II. C++/CLI AND .NET3. Building a C++/CLI Wrapper4. C# Clients: Consuming the Managed WrapperPART III. R AND RCPP5. Building an R Package6. Exposing Functions using RcppPART IV. PYTHON7. Building a Python Extension Module8. Module Development with Boost and PyBind9. ConclusionPART V. APPENDIXESA. Boost LibrariesB. Cmake
Beginning Scala 3
Learn the latest version of Scala through simple, practical examples. This book introduces you to the Scala programming language, its object-oriented and functional programming characteristics, and then guides you through Scala constructs and libraries that allow you to assemble small components into high-performance, scalable systems.Beginning Scala 3 explores new Scala 3 language features such as Top-level declarations, Creator applications, Extension methods to add extra functionality to existing types, and Enums. You will also learn new ways to manipulate types via Union types, intersection, literal, and opaque type aliases. Additionally, you’ll see how Implicits are replaced by given and using clauses.After reading this book, you will understand why Scala is judiciously used for critical business applications by leading companies such as Twitter, LinkedIn, Foursquare, the Guardian, Morgan Stanley, Credit Suisse, UBS, and HSBC – and you will be able to use it in your own projects.WHAT YOU WILL LEARN* Get started with Scala 3 or Scala language programming in general* Understand how to utilitze OOP in Scala* Perform functional programming in Scala* Master the use of Scala collections, traits and implicits* Leverage Java and Scala interopability* Employ Scala for DSL programming* Use patterns and best practices in ScalaWHO THIS BOOK IS FORThose with a background in Java and/or Kotlin who are new to Scala. This book is also for those with some prior Scala experience who want to learn Scala version 3.DAVID POLLAK has been writing commercial software since 1977. He wrote the award-winning Mesa spreadsheet, which in 1992 was the first real-time spreadsheet. Wall Street companies traded billions of dollars a day through Mesa. In 1996, David sold his company to CMP Media and became CTO of CMP Media's NetGuide Live and was one of the first large-scale users of Java and WebLogic to power an Internet site. In 1998, David released Integer, the world's first browser-accessible, multiuser spreadsheet. Since 2000, David has been consulting for companies including Hewlett-Packard, Pretzel Logic/WebGain, BankServ, Twitter, and SAP. David has been using Scala since 2006 and is the lead developer of the Lift Web framework.VISHAL LAYKA is the chief technology officer of Star Protocol. He is involved in the architecture, design, and implementation of distributed business systems, and his focus is on consulting and training with the JVM languages. His language proficiencies include Java, Groovy, Scala, and Haskell. Vishal is also the lead author of Beginning Groovy, Grails, and Griffon (Apress, 2012). When he needs a break from technology, Vishal reads eclectically from calculus to star formation.ANDRES SACCO has been a professional developer since 2007, working with a variety of languages, including Java, Scala, PHP, NodeJs, and Kotlin. Most of his background is in Java and the libraries or frameworks associated with it, but since 2016, he has utilized Scala as well, depending on the situation. He is focused on researching new technologies to improve the performance, stability, and quality of the applications he develops.BEGINNING SCALA 3 (3E)1. Getting started with Scala2. Basics of Scala3. OOP in Scala4. Functional programming in Scala5. Pattern matching6. Scala Collections7. Traits8. Types and Implicits9. Scala and Java Interoperability10. SBT11. Building web applications with Scala12. DSL13. Scala Best practices
Learn JavaFX 17
This unique in-depth tutorial shows you how to start developing rich-client desktop applications using your Java skills and provides comprehensive coverage of JavaFX 17's features. Each chapter starts with an introduction to the topic at hand, followed by a step-by-step discussion of the topic with small snippets of code. The book contains numerous figures aiding readers in visualizing the GUI that is built at every step in the discussion. This book has been revised to include JavaFX 17 and earlier releases since previous edition.It starts with an introduction to JavaFX and its history. It lists the system requirements and the steps to start developing JavaFX applications. It shows you how to create a Hello World application in JavaFX, explaining every line of code in the process. Later in the book, authors Kishori Sharan and Peter Späth discuss advanced topics such as 2D and 3D graphics, charts, FXML, advanced controls, and printing. Some of the advanced controls such as TableView, and WebView are covered at length in separate chapters.This book provides complete and comprehensive coverage of JavaFX 17 features; uses an incremental approach to teach JavaFX, assuming no prior GUI knowledge; includes code snippets, complete programs, and pictures; covers MVC patterns using JavaFX; and covers advanced topics such as FXML, effects, transformations, charts, images, canvas, audio and video, DnD, and more. So, after reading and using this book, you'll come away with a comprehensive introduction to the JavaFX APIs.WHAT YOU WILL LEARN* How to build JavaFX User Interfaces and Java clients* What are properties, bindings, observable collections, stages, scenes; how to use these* How to play with colors, styling nodes and event handling* How to add user interactivity (mouse, keyboard, DnD)* How to do tables, trees and tree tables* How to do 2D shapes, text nodes, 3D shapes* How to apply effects, transformations, animations, images* How to draw; play audio and videoWHO IS THIS BOOK FOR:Developers new to the JavaFX platform. Some prior Java experience is recommended.KISHORI SHARAN has earned a Master of Science in Computer Information Systems degree from Troy State University, Alabama. He is a Sun Certified Java 2 programmer. He has vast experience in providing training to professional developers in Java, JSP, EJB, and Web technology. He possesses over ten years of experience in implementing enterprise level Java application.PETER SPÄTH graduated in 2002 as a physicist and soon afterward became an IT consultant, mainly for Java-related projects. In 2016, he decided to concentrate on writing books on various aspects, but with a main focus on software development. With two books about graphics and sound processing, three books on Android app development, and a beginner’s book on Jakarta EE development, the author continues his effort in writing software development-related literature.Chapter 1. Getting Started with JavaFXChapter 2. Properties and BindingsChapter 3. Observable CollectionsChapter 4. Managing StagesChapter 5. Making ScenesChapter 6. Understanding NodesChapter 7. Playing with ColorsChapter 8. Styling NodesChapter 9. Event HandlingChapter 10. Understanding Layout PanesChapter 11. Model-View-Controller PatternChapter 12. Understanding ControlsChapter 13. Understanding TableViewChapter 14. Understanding TreeViewChapter 15. Understanding TreeTableViewChapter 16. Browsing Web PagesChapter 17. Understanding 2D ShapesChapter 18. Understanding Text NodesChapter 19. Understanding 3D ShapesChapter 20. Applying EffectsChapter 21. Understanding TransformationsChapter 22. Understanding AnimationChapter 24. Understanding ImagesChapter 25. Drawing on a CanvasChapter 26. Understanding Drag-and-DropChapter 27. Understanding Concurrency in JavaFXChapter 28. Playing Audios and VideosChapter 29. Understanding FXMLChapter 30. Printing
C# 10.0 All-in-One For Dummies
LOOK SHARP—LEARN OR REFRESH YOUR C# SKILLS WITH THE LATEST VERSIONC# is one of the most popular programming languages, and frequent updates help it keep pace as the world of coding changes. You can keep pace too, thanks to C# 10.0 All-in-One For Dummies, where you'll learn the basics of the language itself, how to code in Visual Studio, and how to take advantage of the new features in the latest release. At every stage of your career, you'll need to know the cutting-edge trends and techniques that clients want. This book has your back, with info on object-oriented programming, writing secure code, building web applications, and more. The six standalone mini-books you'll find inside this all-in-one will take you through the changes to C# and the practical applications and dev tools that you need to know. New features covered include records, init only setters, top-level statements, pattern matching enhancements, fit and finish features, and a lot more. Plus, this version is packed with more examples and code snippets, so you can sharply see C# in action!* Learn the very basics of C# programming, even if you have no prior experience* Refresh your knowledge of the language and learn how to use the new features in the 10.0 version release* Read six mini-books on hot coding topics like object-oriented programming, Visual Studio, and Windows 10 development* Enhance your employability and join the 6.5-million-strong community of C# developersYou need an easy-to-read C# guide that will help you understand the incoming updates, and this For Dummies reference is it. JOHN PAUL MUELLER is an author and technical editor with experience in application development, database management, machine learning, and deep learning. He has written hundreds of books and articles helping everyday people learn everything from networking to database management.INTRODUCTION 1About This Book 1Foolish Assumptions 2Icons Used in This Book 3Beyond the Book 3Where to Go from Here 4BOOK 1: THE BASICS OF C# PROGRAMMING 5CHAPTER 1: CREATING YOUR FIRST C# CONSOLE APPLICATION 7Getting a Handle on Computer Languages, C#, and NET 8What’s a program? 8What’s C#? 9What’s NET? 9What is Visual Studio 2022? 10Creating Your First Console Application 11Creating the source program 11Taking it out for a test drive 17Making Your Console App Do Something 17Reviewing Your Console Application 18The program framework 19Comments 19The meat of the program 19Replacing All that Ceremonial Code: Top-Level Statements 20Introducing the Toolbox Trick 21Saving code in the Toolbox 22Reusing code from the Toolbox 22Interacting with C# Online 23Working with Jupyter Notebook: The Short Version 23CHAPTER 2: LIVING WITH VARIABILITY — DECLARING VALUE-TYPE VARIABLES 25Declaring a Variable 26What’s an int? 27Rules for declaring variables 28Variations on a theme: Different types of int 28Representing Fractions 30Handling Floating-Point Variables 31Declaring a floating-point variable 31Examining some limitations of floating-point variables 32Using the Decimal Type: Is It an Integer or a Float? 34Declaring a decimal 35Comparing decimals, integers, and floating-point types 35Examining the bool Type: Is It Logical? 36Checking Out Character Types 36The char variable type 36Special chars 37The string type 37What’s a Value Type? 39Comparing string and char 40Calculating Leap Years: DateTime 41Declaring Numeric Constants 43Changing Types: The Cast 44Letting the C# Compiler Infer Data Types 46CHAPTER 3: PULLING STRINGS 49The Union Is Indivisible, and So Are Strings 50Performing Common Operations on a String 51Comparing Strings 52Equality for all strings: The Compare() method 52Would you like your compares with or without case? 56What If I Want to Switch Case? 56Distinguishing between all-uppercase and all-lowercase strings 56Converting a string to upper- or lowercase 57Looping through a String 58Searching Strings 59Can I find it? 59Is my string empty? 60Using advanced pattern matching 60Getting Input from Users in Console Applications 61Trimming excess white space 62Parsing numeric input 62Handling a series of numbers 64Joining an array of strings into one string 66Controlling Output Manually 67Using the Trim() and Pad() methods 67Using the Concatenate() method 69Go Ahead and Split() that concatenate program 71Formatting Your Strings Precisely 72Using the String.Format() method 72Using the interpolation method 77StringBuilder: Manipulating Strings More Efficiently 77CHAPTER 4: SMOOTH OPERATORS 81Performing Arithmetic 81Simple operators 82Operating orders 82The assignment operator 84The increment operator 84Performing Logical Comparisons — Is That Logical? 85Comparing floating-point numbers: Is your float bigger than mine? 86Compounding the confusion with compound logical operations 87Matching Expression Types at TrackDownAMate.com 89Calculating the type of an operation 89Assigning types 91Changing how an operator works: Operator overloading 92CHAPTER 5: GETTING INTO THE PROGRAM FLOW 95Branching Out with if and switch 96Introducing the if statement 97Examining the else statement 100Avoiding even the else 101Nesting if statements 102Running the switchboard 104Here We Go Loop-the-Loop 110Looping for a while 111Doing the do while loop 114Breaking up is easy to do 115Looping until you get it right 116Focusing on scope rules 120Looping a Specified Number of Times with for 120A for loop example 121Why do you need another loop? 122Nesting loops 123CHAPTER 6: LINING UP YOUR DUCKS WITH COLLECTIONS 125The C# Array 126The argument for the array 126The fixed-value array 127The variable-length array 129Initializing an array 132Processing Arrays by Using foreach 133Working with foreach loops in a standard way 133Relying on GetEnumerator support 134Sorting Arrays of Data 136Using var for Arrays 139Loosening Up with C# Collections 140Understanding Collection Syntax 141Figuring out 142Going generic 142Using Lists 143Instantiating an empty list 143Creating a list of type int 144Converting between lists and arrays 144Searching lists 144Performing other list tasks 145Using Dictionaries 145Creating a dictionary 145Searching a dictionary 146Iterating a dictionary 146Array and Collection Initializers 147Initializing arrays 148Initializing collections 148Using Sets 149Performing special set tasks 149Creating a set 150Adding items to a set 150Performing a union 151Performing an intersection 152Performing a difference 153CHAPTER 7: STEPPING THROUGH COLLECTIONS 155Iterating through a Directory of Files 156Using the LoopThroughFiles program 156Getting started 157Obtaining the initial input 157Creating a list of files 159Formatting the output lines 160Displaying the hexadecimal output 161Running from inside Visual Studio 163Iterating foreach Collections: Iterators 164Accessing a collection: The general problem 164Letting C# access data foreach container 167Accessing Collections the Array Way: Indexers 169Indexer format 169An indexer program example 170Looping Around the Iterator Block 173Creating the required iterator block framework 174Iterating days of the month: A first example 176What a collection is, really 177Iterator syntax gives up so easily 178Iterator blocks of all shapes and sizes 180CHAPTER 8: BUYING GENERIC 187Writing a New Prescription: Generics 188Generics are type-safe 188Generics are efficient 189Classy Generics: Writing Your Own 190Shipping packages at OOPs 190Queuing at OOPs: PriorityQueue 191Unwrapping the package 194Touring Main() 196Writing generic code the easy way 197Saving PriorityQueue for last 198Using a (nongeneric) Simple Factory class 201Understanding Variance in Generics 205Contravariance 206Covariance 208CHAPTER 9: SOME EXCEPTIONAL EXCEPTIONS 209Using an Exceptional Error-Reporting Mechanism 210About try blocks 211About catch blocks 211About finally blocks 212What happens when an exception is thrown 213Throwing Exceptions Yourself 215Can I Get an Exceptional Example? 216Working with Custom Exceptions 220Planning Your Exception-Handling Strategy 221Some questions to guide your planning 221Guidelines for code that handles errors well 222How to find out which methods throw which exceptions 223Grabbing Your Last Chance to Catch an Exception 225Throwing Expressions 226CHAPTER 10: CREATING LISTS OF ITEMS WITH ENUMERATIONS 229Seeing Enumerations in the Real World 230Working with Enumerations 231Using the enum keyword 231Creating enumerations with initializers 233Specifying an enumeration data type 234Creating Enumerated Flags 235Defining Enumerated Switches 237Working with Enumeration Methods 238BOOK 2: OBJECT-ORIENTED C# PROGRAMMING 241CHAPTER 1: SHOWING SOME CLASS 243A Quick Overview of Object-Oriented Programming 244Considering OOP basics 244Extending classes to meet other needs 244Keeping objects safe 245Working with objects 246Defining a Class and an Object 246Defining a class 247What’s the object? 249Accessing the Members of an Object 250Working with Object-Based Code 250Using the traditional approach 250Using the C# 9.0 approach 252Discriminating between Objects 253Can You Give Me References? 254Classes That Contain Classes Are the Happiest Classes in the World 256Generating Static in Class Members 257Defining const and readonly Data Members 259CHAPTER 2: WE HAVE OUR METHODS 261Defining and Using a Method 262Method Examples for Your Files 263Understanding the problem 264Working with standard coding methods 265Applying a refactoring approach 268Working with local functions 271Having Arguments with Methods 273Passing an argument to a method 273Passing multiple arguments to methods 274Matching argument definitions with usage 276Overloading a method doesn’t mean giving it too much to do 276Implementing default arguments 278Using the Call-by-Reference Feature 280Defining a Method with No Return Value 281Returning Multiple Values Using Tuples 282Using a tuple 283Relying on the Create() method 284Creating tuples with more than two items 284CHAPTER 3: LET ME SAY THIS ABOUT THIS 287Passing an Object to a Method 288Comparing Static and Instance Methods 290Employing static properties and methods effectively 291Employing instance properties and methods effectively 293Expanding a method’s full name 295Accessing the Current Object 296What is the this keyword? 298When is the this keyword explicit? 299Using Local Functions 300Creating a basic local function 300Using attributes with local functions 301CHAPTER 4: HOLDING A CLASS RESPONSIBLE 303Restricting Access to Class Members 303A public example of public BankAccount 304Jumping ahead — other levels of security 306Why You Should Worry about Access Control 307Accessor methods 308Working with init-only setters 309Access control to the rescue — an example 311Defining Class Properties 313Static properties 315Properties with side effects 315Accessors with access levels 316Using Target Typing for Your Convenience 316Dealing with Covariant Return Types 319Getting Your Objects Off to a Good Start — Constructors 320The C#-Provided Constructor 321Replacing the Default Constructor 322Constructing something 324Initializing an object directly with an initializer 326Seeing that construction stuff with initializers 326Initializing an object without a constructor 327Using Expression-Bodied Members 329Creating expression-bodied methods 329Defining expression-bodied properties 329Defining expression-bodied constructors and destructors 330Defining expression-bodied property accessors 330Defining expression-bodied event accessors 331CHAPTER 5: INHERITANCE: IS THAT ALL I GET? 333Why You Need Inheritance 334Inheriting from a BankAccount Class (a More Complex Example) 335Working with the basic update 336Tracking the BankAccount and SavingsAccount classes features 339IS_A versus HAS_A — I’m So Confused_A 342The IS_A relationship 342Gaining access to BankAccount by using containment 343The HAS_A relationship 345When to IS_A and When to HAS_A 346Other Features That Support Inheritance 346Substitutable classes 346Invalid casts at runtime 347Avoiding invalid conversions with the is operator 348Avoiding invalid conversions with the as operator 349CHAPTER 6: POLY-WHAT-ISM? 353Overloading an Inherited Method 354It’s a simple case of method overloading 354Different class, different method 355Peek-a-boo — hiding a base class method 355Polymorphism 361Using the declared type every time (Is that so wrong?) 362Using is to access a hidden method polymorphically 364Declaring a method virtual and overriding it 365Getting the most benefit from polymorphism 368C# During Its Abstract Period 368Class factoring 369The abstract class: Left with nothing but a concept 373How do you use an abstract class? 374Creating an abstract object — not! 377Sealing a Class 377CHAPTER 7: INTERFACING WITH THE INTERFACE 379Introducing CAN_BE_USED_AS 379Knowing What an Interface Is 381How to implement an interface 382Using the newer C# 8.0 additions 383How to name your interface 386Why C# includes interfaces 386Mixing inheritance and interface implementation 387And he-e-e-re’s the payoff 387Using an Interface 388As a method return type 389As the base type of an array or collection 389As a more general type of object reference 390Using the C# Predefined Interface Types 390Looking at a Program That CAN_BE_USED_AS an Example 391Creating your own interface at home in your spare time 391Implementing the incomparable I Comparable interface 392Creating a list of students 394Testing everything using Main() 395Unifying Class Hierarchies 396Hiding Behind an Interface 399Inheriting an Interface 401Using Interfaces to Manage Change in Object-Oriented Programs 402Making flexible dependencies through interfaces 403Abstract or concrete: When to use an abstract class and when to use an interface 404Doing HAS_A with interfaces 405CHAPTER 8: DELEGATING THOSE IMPORTANT EVENTS 407E.T., Phone Home — The Callback Problem 408Defining a Delegate 408Pass Me the Code, Please — Examples 411Delegating the task 411First, a simple example 412Considering the Action, Func, and Predicate delegate types 413A More Real-World Example 415Putting the app together 416Setting the properties and adding event handlers 418Looking at the workhorse code 419Shh! Keep It Quiet — Anonymous Methods 421Defining the basic anonymous method 421Using static anonymous methods 422Working with lambda discard parameters 424Stuff Happens — C# Events 424The Observer design pattern 425What’s an event? Publish/Subscribe 425How a publisher advertises its events 426How subscribers subscribe to an event 427How to publish an event 427How to pass extra information to an event handler 428A recommended way to raise your events 429How observers “handle” an event 430CHAPTER 9: CAN I USE YOUR NAMESPACE IN THE LIBRARY? 433Dividing a Single Program into Multiple Source Files 434Working with Global using Statements 435Dividing a Single Program into Multiple Assemblies 437Executable or library? 437Assemblies 437Executables 438Class libraries 439Putting Your Classes into Class Libraries 439Creating the projects for a class library 439Creating a stand-alone class library 440Adding a second project to an existing solution 442Creating the code for the library 445Using a test application to test a library 446Going Beyond Public and Private: More Access Keywords 448Internal: For CIA eyes only 448Protected: Sharing with subclasses 451Putting Classes into Namespaces 453Declaring a namespace 454Using file-scoped namespaces 456Relating namespaces to the access keyword story 456Using fully qualified names 458Working with partial classes 459Working with Partial Methods 463Defining what partial methods do 463Creating a partial method 464CHAPTER 10: IMPROVING PRODUCTIVITY WITH NAMED AND OPTIONAL PARAMETERS 465Exploring Optional Parameters 466Working with optional value parameters 466Avoiding optional reference types 468Looking at Named Parameters 470Using Alternative Methods to Return Values 470Output (out) parameters 471Working with out variables 471Returning values by reference 472Dealing with null Parameters 473CHAPTER 11: INTERACTING WITH STRUCTURES 475Comparing Structures to Classes 476Considering struct limits 476Understanding the value type difference 477Determining when to use struct versus class 477Creating Structures 478Defining a basic struct 478Including common struct elements 479Using supplemental struct elements 482Working with Read-only Structures 485Working with Reference Structures 487Using Structures as Records 489Managing a single record 489Adding structures to arrays 489Overriding methods 490Using the New Record Type 491Comparing records to structures and classes 491Working with a record 492Using the positional syntax for property definition 493Understanding value equality 494Creating safe changes: Nondestructive mutation 494Using the field keyword 495BOOK 3: DESIGNING FOR C# 497CHAPTER 1: WRITING SECURE CODE 499Designing Secure Software 500Determining what to protect 500Documenting the components of the program 501Decomposing components into functions 502Identifying potential threats in functions 502Building Secure Windows Applications 503Authentication using Windows logon 503Encrypting information 507Deployment security 507Using System.Security 508CHAPTER 2: ACCESSING DATA 509Getting to Know System.Data 510How the Data Classes Fit into the Framework 512Getting to Your Data 512Using the System.Data Namespace 513Setting up a sample database schema 513Creating the data access project 514Connecting to a data source 514Working with the visual tools 519Writing data code 521CHAPTER 3: FISHING THE FILE STREAM 525Going Where the Fish Are: The File Stream 525Streams 526Readers and writers 527StreamWriting for Old Walter 528Using the stream: An example 529Using some better fishing gear: The using statement 534Pulling Them Out of the Stream: Using StreamReader 537More Readers and Writers 539Exploring More Streams than Lewis and Clark 541CHAPTER 4: ACCESSING THE INTERNET 543Getting to Know System.Net 544How Net Classes Fit into the Framework 545Understanding the System.Net subordinate namespaces 545Working with the System.Net classes 548Using the System.Net Namespace 549Checking the network status 549Downloading a file from the Internet 551Emailing a status report 553Logging network activity 556CHAPTER 5: CREATING IMAGES 559Getting to Know System.Drawing 560Graphics 561Pens 562Brushes 563Text 563How the Drawing Classes Fit into the Framework 564Using the System.Drawing Namespace 565Getting started 565Setting up the project 567Handling the score 567Creating an event connection 569Drawing the board 570Printing the score 572Starting a new game 574CHAPTER 6: PROGRAMMING DYNAMICALLY! 575Shifting C# Toward Dynamic Typing 576Employing Dynamic Programming Techniques 578Putting Dynamic to Use 580Classic examples 580Making static operations dynamic 581Understanding what’s happening under the covers 581Running with the Dynamic Language Runtime 582Using Static Anonymous Functions 585BOOK 4: A TOUR OF VISUAL STUDIO 587CHAPTER 1: GETTING STARTED WITH VISUAL STUDIO 589Versioning the Versions 590An overview of Visual Studio 2022 updates 590Community edition 592Professional edition 594Enterprise edition 594MSDN 595Installing Visual Studio 596Breaking Down the Projects 597Exploring the Create a New Project dialog box 600Understanding solutions and projects 601CHAPTER 2: USING THE INTERFACE 603Designing in the Designer 604Universal Windows Platform (UWP) application 604Windows Presentation Foundation (WPF) 607Windows Forms 609Data View 609Paneling the Studio 610Solution Explorer 610Properties 613The Toolbox 614Server Explorer 615Class View 617Coding in the Code Editor 618Exercising the Code Editor 618Exploring the auxiliary windows 619Using the Tools of the Trade 621The Tools menu 622Building 623Using the Debugger as an Aid to Learning 623Stepping through code 623Going to a particular code location 624Watching application data 625Viewing application internals 626CHAPTER 3: CUSTOMIZING VISUAL STUDIO 627Setting Options 628Environment 629Language 630Neat stuff 631Creating Your Own Templates 632Developing a project template 632Developing an item template 635BOOK 5: WINDOWS DEVELOPMENT WITH WPF 639CHAPTER 1: INTRODUCING WPF 641Understanding What WPF Can Do 642Introducing XAML 643Diving In! Creating Your First WPF Application 644Declaring an application-scoped resource 647Making the application do something 648Whatever XAML Can Do, C# Can Do Better! 650CHAPTER 2: UNDERSTANDING THE BASICS OF WPF 653Using WPF to Lay Out Your Application 654Arranging Elements with Layout Panels 655The Stack panel 656The Wrap panel 660The Dock panel 661Canvas 662The Grid 662Putting it all together with a simple data entry form 669Exploring Common XAML Controls 672Display-only controls 672Basic input controls 674List-based controls 677CHAPTER 3: DATA BINDING IN WPF 681Getting to Know Dependency Properties 682Exploring the Binding Modes 683Investigating the Binding Object 683Defining a binding with XAML 684Defining a binding with C# 686Editing, Validating, Converting, and Visualizing Your Data 687Validating data 693Converting your data 697Finding Out More about WPF Data Binding 705CHAPTER 4: PRACTICAL WPF 707Commanding Attention 708Traditional event handling 708ICommand 709Routed commands 710Using Built-In Commands 711Using Custom Commands 713Defining the interface 713Creating the window binding 714Ensuring that the command can execute 714Performing the task 715Using Routed Commands 717Defining the Command class 717Making the namespace accessible 718Adding the command bindings 718Developing a user interface 718Developing the custom command code-behind 719CHAPTER 5: PROGRAMMING FOR WINDOWS 10 AND ABOVE 721What is the Universal Windows Platform (UWP)? 722Devices Supported by the UWP 725Creating Your Own UWP App 726Configuring Developer Mode 726Defining the project 732Creating an interface 734Adding some background code 738Choosing a test device 739Working with NET Core Applications 740BOOK 6: WEB DEVELOPMENT WITH ASP.NET 743CHAPTER 1: CREATING A BASIC ASP.NET CORE APP 745Understanding the ASP.NET Core Templates 746Starting with nothing using ASP.NET Core Empty 746Creating a basic app using the ASP.NET Core Web App 748Fumbling around with HTTPS-enabled sites 749Building in business logic using ASP.NET Core App (Model-View-Controller) 751Developing a programming interface using ASP.NETCore Web API 752An overview of those other weird templates 753Developing a Basic Web App 754Creating the project 754Considering the development process 756Adding web content 757Making some basic changes to the first page 759CHAPTER 2: EMPLOYING THE RAZOR MARKUP LANGUAGE 761Avoiding Nicks from Razor 762Comparing Razor to its predecessors 762Considering the actual file layout 763Understanding the syntax rules for C# 766Working with some Razor basics 767Creating Variables 770Keeping Things Logical 771Starting simply by using if 771Sleeping at the switch 771Implementing Loops 772Creating an array 772Performing tasks a specific number of times using for 773Processing an unknown number of times using for each and while 773CHAPTER 3: GENERATING AND CONSUMING DATA 775Understanding Why These Projects Are Important 776Serialized Data Isn’t for Breakfast 777Developing a Data Generator and API 778Creating the WeatherForecast project 778Making the data believable 781Looking at the API configuration 783Checking the API for functionality 784Creating a Consumer Website 786Creating the RetrieveWeatherForecast project 786Developing a user interface 787Getting and deserializing the data 789Seeing the application in action 793Index 795
Go programmieren für Dummies
Go ist eine der neueren Programmiersprachen, die Softwareentwickler in ihrer Werkzeugkiste haben sollten. Die Sprache wurde mit dem Ziel entwickelt, besonders gut lesbar, benutzerfreundlich und effizient zu sein, und ist eine gute Wahl für Entwickler, die Anwendungen für die Cloud erstellen. Dieses Buch zeigt Ihnen die ersten Schritte in Go. Steigen Sie ein und beginnen Sie mit dem Schreiben von Code, der Daten aus der Cloud holt und sie in die Hände der Benutzer legt.Wei-Meng Lee ist Gründer des Unternehmens Developer Learning Solutions, das Schulungen zu den neuesten mobilen Technologien anbietet. Nach dem Motto »Learning by Doing« legt er in seinen Kursen besonderen Wert auf Praxisorientierung und schafft es dank seiner langjährigen Erfahrung, komplexe Technologietrends verständlich zu erklären. Wei-Meng Lee schreibt regelmäßig für Online- und Printpublikationen und ist Autor mehrerer Bücher.
Pro Go
Best-selling author Adam Freeman explains how to get the most from Go, starting from the basics and building up to the most advanced and sophisticated features. You will learn how Go builds on a simple and consistent type system to create a comprehensive and productive development experience that produces fast and robust applications that run across platforms.Go, also known as Golang, is the concise and efficient programming language designed by Google for creating high-performance, cross-platform applications. Go combines strong static types with simple syntax and a comprehensive standard library to increase programmer productivity, while still supporting features such as concurrent/parallel programming.Each topic is covered in a clear, concise, no-nonsense approach that is packed with the details you need to learn to be truly effective. Chapters include common problems and how to avoid them.WHAT YOU WILL LEARN* Gain a solid understanding of the Go language and tools* Gain in-depth knowledge of the Go standard library* Use Go for concurrent/parallel tasks* Use Go for client- and server-side development WHO THIS BOOK IS FORExperienced developers who want to use Go to create applicationsADAM FREEMAN is an experienced IT professional who has held senior positions in a range of companies, most recently serving as chief technology officer and chief operating officer of a global bank. Now retired, he spends his time writing and long-distance running.Part 1 - Understanding the Go Language1. Your First Go App2. Putting Go in Context3. Using the Go Tools4. Basic Types, Values, and Pointers5. Operations and Conversions6. Flow Control7. Using Arrays, Slice, and Maps8. Defining and Using Functions9. Using Function Types10. Defining Structs11. Using Methods and Interfaces12. Creating and Using Packages13. Type and Interface Composition14. Using Goroutines and Channels15. Error HandlingPart 2 - Using the Go Standard Library16. String Processing and Regular Expressions 17. Formatting and Scanning Strings 18. Math Functions and Data Sorting 19. Dates, Times, and Durations 20. Reading and Writing Data 21. Working with JSON Data 22. Working with Files 23. Using HTML and Text Templates 24. Creating HTTP Servers 25. Creating HTTP Clients 26. Working with Databases 27. Using Reflection 28. Using Reflection, Part 2 29. Using Reflection, Part 3 30. Coordinating Goroutines 31. Unit Testing, Benchmarking, and LoggingPart 3 - Applying Go32. Creating a Web Platform33. Middleware, Templates, and Handlers34. Actions, Sessions, and Authorization 35. SportsStore: A Real Application 36. SportsStore: Cart and Database 37. SportsStore: Checkout and Administration 38. SportsStore: Finishing and Deployment
Data-Science-Crashkurs
Eine interaktive und praktische Einführung: Data Science praxisnah erklärt»Data Science Crashkurs« bietet einen praxisnahen Einstieg in Data Science, angereichert mit interaktiven Elementen, der die Breite der Möglichkeiten der Datenanalyse aufzeigt. Dieses Buch geht tief genug, um Vorteile, Nachteile und Risiken zu verstehen, aber steigt dennoch nicht zu tief in die zugrunde liegende Mathematik ein. Es wird nicht nur erklärt, wofür wichtige Begriffe wie Big Data, maschinelles Lernen oder Klassifikation stehen, sondern auch anschaulich mit zahlreichen Beispielen aufgezeigt, wie Daten analysiert werden. Ein breiter Überblick über Analysemethoden vermittelt das nötige Wissen, um in eigenen Projekten geeignete Methoden auszuwählen und anzuwenden, um das gewünschte Ergebnis zu erreichen. Der benötigte Python-Quelltext, der z.B. zur Durchführung von Analysen oder zur Erstellung von Visualisierungen verwendet wird, ist in Form von Jupyter-Notebooks frei verfügbar. Zielgruppe: Data ScientistsDatenanalyst*innenDaten- und InformationsverantwortlicheStudierende der Informatik und Wirtschaftsinformatik Autor: Dr. Steffen Herbold ist Professor für Methoden und Anwendungen maschinellen Lernens am Institut für Software und Systems Engineering der Technischen Universität Clausthal, wo er die Forschungsgruppe AI Engineering leitet. Zuvor hat er an der Universität Göttingen promoviert und habilitiert und am Karlsruher Institut für Technologie einen Lehrstuhl vertreten. In der Forschung beschäftigt er sich mit der Entwicklung und Qualitätssicherung der Lösung von Problemen durch maschinelles Lernen, z.B. zur effizienteren Softwareentwicklung, der Prognose von Ernteerträgen oder auch der Erkennung von aeroakustischen Geräuschquellen.
Numerical Methods Using Java
Implement 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* Convert ideas and equations into code* Put together algorithms and classes to build your own engineering solution* Build solvers for industrial optimization problems* Do data analysis using basic and advanced statisticsWHO THIS BOOK IS FORProgrammers, data scientists, and analysts with prior experience with programming in any language, especially Java.HAKSUN LI, PHD, is founder of NM Group, a scientific and mathematical research company. He has the vision of “Making the World Better Using Mathematics”. Under his leadership, the firm serves worldwide brokerage houses and funds, multinational corporations and very high net worth individuals. Haksun is an expert in options trading, asset allocation, portfolio optimization and fixed-income product pricing. He has coded up a variety of numerical software, including SuanShu (a library of numerical methods), NM Dev (a library of numerical methods), AlgoQuant (a library for financial analytics), NMRMS (a portfolio management system for equities), and supercurve (a fixed-income options pricing system). Prior to this, Haksun was a quantitative trader/quantitative analyst with multiple investment banks. He has worked in New York, London, Tokyo, and Singapore.Additionally, Haksun is the vice dean of the Big Data Finance and Investment Institute of Fudan University, China. He was an adjunct professor with multiple universities. He has taught at the National University of Singapore (mathematics), Nanyang Technological University (business school), Fudan University (economics), as well as Hong Kong University of Science and Technology (mathematics). Dr. Haksun Li has a B.S. and M.S. in pure and financial mathematics from the University of Chicago, and an M.S. and a PhD in computer science and engineering from the University of Michigan, Ann Arbor.Table 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 .....................................................................................................
Pro Jakarta Persistence in Jakarta EE 10
Learn to use the Jakarta Persistence API and other related APIs as found in the Jakarta EE 10 platform from the perspective of one of the specification creators. A one-of-a-kind resource, this in-depth book provides both theoretical and practical coverage of Jakarta Persistence usage for experienced Java developers.Authors Lukas Jungmann, Mike Keith, Merrick Schincariol, Massimo Nardone take a hands-on approach, based on their wealth of experience and expertise, by giving examples to illustrate each concept of the API and showing how it is used in practice. The examples use a common model from an overarching sample application, giving you a context from which to start and helping you to understand the examples within an already familiar domain.After completing this in-depth book, you will have a full understanding of persistence and be able to successfully code applications using its annotations and APIs. The book also serves as an excellent reference guide.WHAT YOU WILL LEARN* Use Jakarta Persistence in the context of enterprise applications* Work with object relational mappings (ORMs), collection mappings and more* Build complex enterprise Java applications that persist data long after the process terminates* Connect to and persist data with a variety of databases, file formats, and more* Use queries, including the Jakarta Persistence Query Language (Jakarta Persistence QL)* Carry out advanced ORM, queries and XML mappings* Package, deploy and test your Jakarta persistence-enabled enterprise applicationsWHO THIS BOOK IS FORExperienced Java programmers and developers with at least some prior experience with Jakarta EE or Java EE platform APIs.LUKAS JUNGMANN is the specification project co-lead for Jakarta Persistence, and the lead for a number of other Jakarta Specification projects including Jakarta Activation, Mail, XML Binding, SOAP with Attachments, and XML Web Services. He is a contributor to Jakarta Platform, JSON Processing, JSON Binding specification projects and is lead for a number of implementation projects of various Jakarta specifications including EclipseLink, Eclipse Metro and Eclipse Angus. He holds a Bachelor’s degree in Applied Informatics from University of Finance and Administration in Prague, Czech Republic, and has over 15 years’ experience working with Enterprise Java related technologies. He has spoken at numerous conferences around the world. He is employed as a software developer at Oracle in Prague, Czech Republic, and is married with three kids and one cat.MIKE KEITH is a co-specification lead for JPA 1.0 and a member of the JPA 2.0 and JPA 2.1 expert groups. He sits on a number of other Java Community Process expert groups and the Enterprise Expert Group (EEG) in the OSGi Alliance. He holds a Masters degree in Computer Science from Carleton University, and has over 20 years experience in persistence and distributed systems research and practice.He has written papers and articles on JPA and spoken at numerous conferences around the world. He is employed as an architect at Oracle in Ottawa, Canada,and is married with four kids and two dogs.MERRICK SCHINCARIOL is a senior engineer for the Oracle OC4J Java EE Container. He was a lead engineer for Oracle's EJB 3.0 release and co-author of Pro EJB 3: Java Persistence API. Before joining Oracle, Merrick developed enterprise and large-scale systems for the telecommunications industry.MASSIMO NARDONE has more than 23 years of experiences in Security, Web/Mobile development, Cloud and IT Architecture and has been programming and teaching how to program with Android, Perl, PHP, Java, VB, Python, C/C++ and MySQL for more than 20 years. He currently works as Chief Information Security Office (CISO) for Cargotec Oyj and he is member of the ISACA Finland Chapter Board. Massimo has provided technical review for more than 40 IT books, and is the coauthor of Pro Android Games (Apress, 2015).* Introduction * Getting Started * Enterprise Applications * Object Relational Mapping * Collection Mapping * Entity Manager * Using Queries * Java Persistence Query Language * Criteria * Advanced Object Relational Mapping * Advanced Queries * Advanced Topics * XML Mapping Files * Packaging and Deployment * Testing
Handbuch für Softwareentwickler
Das Standardwerk für professionelles Software Engineering. Jeder Entwickler weiß, dass es mit der Kenntnis von Sprachen und Programmierplattformen nicht getan ist. Wer erfolgreich Software entwickeln möchte, sollte mit vielen Fachgebieten und Methoden vertraut sein – von der Architektur über Datenhaltung, Anforderungsmanagement, Sicherheitsfragen bis zum Projektmanagement. Hier finden Sie eine umfassende Behandlung dieser Themenvielfalt. Das Autorenteam gibt praktische Empfehlungen zu grundlegenden und aktuellen Fragen der professionellen Softwareentwicklung. Das theoretische Fundament und die gut erläuterten Fachbegriffe sind dabei niemals Selbstzweck, sondern stehen im Dienst der Kunst, für Ihre Kunden gute Software zu entwickeln Aus dem Inhalt: Grundlagen: Algorithmen und DatenstrukturenAnforderungsanalyse, Planung und EntwurfGelungene User InterfacesKundenzufriedenheit und BenutzerfreundlichkeitMigration – vom Altsystem zur zeitgemäßen AnwendungDatensicherheit, Datenschutz und VerschlüsselungGuter Code und QualitätsmaßstäbePlattformübergreifende EntwicklungParallelprogrammierungSoftwaretestingMobile Computing im Enterprise-UmfeldÜberblick über Werkzeuge wie Entwicklungsumgebungen und Versionsverwaltung Materialien zum Buch ... 20 Vorwort ... 21 TEIL I. Überblick ... 23 1. Überblick ... 25 1.1 ... Berufswunsch Softwareentwickler ... 25 1.2 ... Über dieses Buch ... 32 1.3 ... Quellen der zitierten Statistiken ... 37 2. Programmierung als Kern der Softwareentwicklung ... 39 2.1 ... Die Programmierung ... 39 2.2 ... Paradigmen der Softwareentwicklung ... 43 2.3 ... Objektorientierte Programmentwicklung ... 44 2.4 ... Programmiersprachen ... 66 2.5 ... Essenzielle Sprachmerkmale ... 76 2.6 ... Fazit und Ausblick ... 106 2.7 ... Literatur und Links ... 107 3. Algorithmen und Datenstrukturen ... 109 3.1 ... Algorithmen als Kernelemente des Programms ... 110 3.2 ... Entwurf von Algorithmen ... 115 3.3 ... Sortieren und Suchen als Basisalgorithmen ... 128 3.4 ... Elementare Datenstrukturen ... 148 3.5 ... Zusammenfassung und Ausblick ... 170 3.6 ... Literatur und Links ... 172 TEIL II. Der Softwarelebenszyklus ... 175 4. Softwareprojekte professionell planen ... 177 4.1 ... Der Wasserfall ... 178 4.2 ... Iterative Entwicklung -- schrittweise zum Ziel ... 183 4.3 ... Das V-Modell -- eine Struktur hauptsächlich für Projekte der öffentlichen Hand ... 185 4.4 ... Bessere Risikobeherrschung durch das Spiralmodell ... 186 4.5 ... Agile Ansätze -- der Komplexität und Unsicherheit mit Flexibilität begegnen ... 187 4.6 ... Softwareentwicklung und die Schnittstellen zum Projektmanagement ... 199 4.7 ... Ist Agilität heute alternativlos? ... 207 4.8 ... Literatur und Links ... 209 5. Die Anforderungsanalyse -- Startpunkt der Entwicklung ... 211 5.1 ... Überblick und Zielstellung ... 211 5.2 ... Ausgangssituation und Notwendigkeit ... 214 5.3 ... Anforderungen ermitteln ... 218 5.4 ... Klassische Anforderungsanalyse ... 237 5.5 ... Agile Anforderungsanalyse ... 248 5.6 ... Toolunterstützung ... 252 5.7 ... Fazit ... 256 5.8 ... Literatur und Links ... 256 6. Der Entwurf des Softwaresystems ... 259 6.1 ... Die Softwarearchitektur als Basis für Erfolg und Wartbarkeit eines Softwaresystems ... 260 6.2 ... Architekturparadigmen ... 266 6.3 ... Entwurfsmuster als Baupläne ... 291 6.4 ... Entwurfsunterstützung durch grafische Modellierung ... 297 6.5 ... Weitere Entwurfsentscheidungen ... 301 6.6 ... Erfolgreiche Entwürfe mithilfe von Prototypen ... 304 6.7 ... Zusammenfassung und Fazit ... 312 6.8 ... Literatur und Links ... 313 7. Die Implementierung schafft den Kern der Anwendung ... 315 7.1 ... Die Entwicklung der Benutzerschnittstelle ... 316 7.2 ... Die Businesslogik umsetzen ... 346 7.3 ... Die Datenwelt anbinden ... 348 7.4 ... Zusammenfassung und Fazit ... 351 7.5 ... Literatur und Links ... 351 8. Testen als Voraussetzung für fehlerarme Software ... 353 8.1 ... Zur Notwendigkeit von Softwaretests ... 354 8.2 ... Testgetriebene Entwicklung ... 355 8.3 ... Ein Überblick über wichtige Testarten ... 357 8.4 ... Testmethoden ... 361 8.5 ... Testebenen ... 369 8.6 ... Technik des Testens ... 387 8.7 ... Fazit und Zusammenfassung ... 391 8.8 ... Literatur und Links ... 391 9. Distribution -- das Produkt muss zum Kunden ... 393 9.1 ... Die Softwaredistribution im Überblick ... 394 9.2 ... Automatisierte Softwareverteilung ... 405 9.3 ... Verbesserte Zusammenarbeit durch DevOps ... 408 9.4 ... Die Nutzung der App Stores ... 411 9.5 ... Die Technik der Softwarebereitstellung ... 417 9.6 ... Fazit ... 437 9.7 ... Literatur und Links ... 437 10. Vom Altsystem zur zeitgemäßen Anwendung ... 439 10.1 ... Technologien im Wandel ... 440 10.2 ... Notwendigkeit einer Softwaremigration ... 442 10.3 ... Ziele einer Softwaremigration ... 444 10.4 ... Planung der Migration ... 444 10.5 ... Migrationsstrategien ... 447 10.6 ... Arten der Migration ... 451 10.7 ... Wirtschaftlichkeitsbetrachtungen ... 453 10.8 ... Stolpersteine ... 454 10.9 ... Eine Fallstudie ... 455 10.10 ... Literatur und Links ... 473 TEIL III. Technologien und Methoden ... 475 11. Webtechnologien ... 477 11.1 ... Einführung ... 477 11.2 ... Zusammenspiel von HTML, CSS und JavaScript ... 478 11.3 ... Die Struktur einer Webseite mit HTML ... 480 11.4 ... HTML Basics ... 481 11.5 ... Das Layout und das Design einer Webseite mit CSS ... 487 11.6 ... Logik und Interaktion mit JavaScript ... 504 11.7 ... Klassenbibliotheken und Frameworks ... 519 11.8 ... Fazit ... 529 11.9 ... Literatur und Links ... 529 12. Apps für mobile Systeme ... 531 12.1 ... Arten von Apps ... 533 12.2 ... Native Apps ... 535 12.3 ... Web-Apps ... 553 12.4 ... Hybride Apps ... 555 12.5 ... Plattformübergreifende Ansätze ... 557 12.6 ... Auswahlkriterien ... 571 12.7 ... Sensoren ... 577 12.8 ... Emulation und Simulation ... 584 12.9 ... Backend as Service ... 591 12.10 ... Fazit ... 599 12.11 ... Literatur und Links ... 599 13. Plattform- und geräteübergreifende Entwicklung ... 601 13.1 ... Nutzerinnen und Nutzer im Fokus ... 602 13.2 ... Ansätze für die plattformübergreifende Entwicklung ... 604 13.3 ... Ein Beispiel mit RAD Studio ... 614 13.4 ... Fazit ... 617 13.5 ... Literatur und Links ... 618 14. Parallelprogrammierung ... 619 14.1 ... Systemtechnische Ebene ... 620 14.2 ... Anwendungsebene ... 626 14.3 ... Programmiertechnische Ebene ... 634 14.4 ... Zusammenfassung ... 638 14.5 ... Literatur und Links ... 638 15. Kundenzufriedenheit durch Nutzerorientierung ... 641 15.1 ... Die Nutzer im Fokus ... 644 15.2 ... Benutzerschnittstellen im Wandel ... 648 15.3 ... Gestaltung von Benutzeroberflächen ... 660 15.4 ... Literatur und Links ... 668 16. Datensicherheit und Datenschutz ... 671 16.1 ... Begriffe und Angrenzungen ... 674 16.2 ... Überblick über die Datenschutz-Grundverordnung ... 676 16.3 ... Datenschutz und Cloud-Computing ... 679 16.4 ... Technischer Datenschutz ... 681 16.5 ... Fazit ... 697 16.6 ... Literatur und Links ... 697 17. Grundlagen der Datenhaltung ... 699 17.1 ... Datenbank -- ein Ort, um Ordnung zu halten ... 699 17.2 ... Phasen der Datenbankentwicklung ... 708 17.3 ... Relationale Datenbanken ... 711 17.4 ... NoSQL-Datenbanken ... 726 17.5 ... Fazit und Ausblick ... 735 17.6 ... Literatur und Links ... 735 18. Werkzeugunterstützung ... 737 18.1 ... Die Rolle von Werkzeugen ... 738 18.2 ... Integrierte Entwicklungsumgebungen als Multifunktionswerkzeuge ... 739 18.3 ... Versionsverwaltungen als Voraussetzung für eine erfolgreiche Entwicklung ... 744 18.4 ... Weitere Softwaretools für die Entwicklung ... 754 18.5 ... Fazit und Ausblick ... 758 18.6 ... Literatur und Links ... 759 19. Qualitätssicherung und Clean Code Development ... 761 19.1 ... Das Verständnis von Softwarequalität ... 761 19.2 ... Ansätze zur Bestimmung der Softwarequalität ... 764 19.3 ... Softwarequalität zwischen Nutzen und Kosten ... 769 19.4 ... Qualität verbessern ... 771 19.5 ... Eine gesunde Fehlerkultur ... 786 19.6 ... Fazit und Zusammenfassung ... 793 19.7 ... Literatur und Links ... 793 TEIL IV. Trends ... 795 20. Enterprise Mobile Computing ... 797 20.1 ... Einsatzszenarien ... 798 20.2 ... Bring Your Own Device ... 807 20.3 ... Technische Aspekte für Enterprise Mobile Computing ... 817 20.4 ... Fazit und Ausblick ... 829 20.5 ... Literatur und Links ... 829 21. Internet of Things ... 831 21.1 ... Stand heute und Zukunftsszenarien ... 832 21.2 ... IoT-Infrastruktur ... 841 21.3 ... Hardware auf kleinstem Raum ... 850 21.4 ... Fallbeispiel: Windows 10 auf dem Raspberry Pi ... 854 21.5 ... Fazit und Ausblick ... 866 21.6 ... Literatur und Links ... 867 22. Cloud-Computing ... 869 22.1 ... Grundlagen des Cloud-Computings ... 870 22.2 ... Ökonomische Gesichtspunkte ... 876 22.3 ... Cloud-Computing als Werkzeug der Softwareentwicklung ... 881 22.4 ... Fazit ... 885 22.5 ... Literatur und Links ... 885 Index ... 887
PyTorch kompakt
Syntax, Design Patterns und Codebeispiele für Deep-Learning-Modelle Mit diesem benutzerfreundlichen Nachschlagewerk zu PyTorch haben Sie kompaktes Wissen zu einem der beliebtesten Frameworks für Deep Learning immer zur Hand. Der Autor Joe Papa bietet Ihnen mit dieser Referenz den sofortigen Zugriff auf Syntax, Design Patterns und gut nachvollziehbare Codebeispiele. Sie erhalten eine Fülle an gesammelten Informationen, die Ihre Entwicklungsarbeit beschleunigen und die Zeit minimieren, die Sie mit der Suche nach Details verbringen. Leseprobe (PDF-Link)Inhaltsverzeichnis (PDF-Link)Zielgruppe:Data ScientistsSoftwareentwickler*innenDatenanalyst*innenStudierende der Informatik Autor: Joe Papa verfügt über 25 Jahre Erfahrung in Forschung und Entwicklung und ist Gründer von TeachMe.AI. Seinen Abschluss „Master of Science in Electrical Engineering“ hat er an der Universität Rutgers erworben. Bei Booz Allen Hamilton und Perspecta Labs hat er KI-Forschungsteams mit PyTorch geleitet. Joe hat Hunderte von Datenwissenschaftlern als Mentor betreut und mehr als 6.000 Studenten auf der ganzen Welt auf Udemy unterrichtet.
Java 17 for Absolute Beginners
Write your first code in Java 17 using simple, step-by-step examples that model real-word objects and events, making learning easy. With Java 17 for Absolute Beginners you’ll be able to pick up the concepts without fuss. It teaches Java development in language anyone can understand, giving you the best possible start.You’ll see clear code descriptions and layout so that you can get your code running as soon as possible. Author Iuliana Cosmina focuses on practical knowledge and getting you up to speed quickly—all the bits and pieces a novice needs to get started programming in Java.First, you’ll discover what type of language Java is, what it is good for, and how it is executed. With the theory out of the way, you’ll install Java, choose an editor such as IntelliJ IDEA, and write your first simple Java program. Along the way you’ll compile and execute this program so it can run on any platform that supports Java. As part of this tutorial you’ll see how to write high-quality code by following conventions and respecting well-known programming principles, making your projects more professional and efficient.Java 17 for Absolute Beginners gives you all you need to start your Java programming journey. No experience necessary. After reading this book, you'll come away with the basics to get started writing programs in Java.WHAT YOU WILL LEARN* Get started with Java 17 from scratchUse data types, operators, and the stream API * Install and use the IntelliJ IDEA and the Gradle build tool* Exchange data using the new JSON APIs * Play with images using multi-resolution APIs* Implement the publish-subscribe architectureWHO THIS BOOK IS FORThose who are new to programming and who want to start with Java.IULIANA COSMINA is currently a software engineer for NCR Edinburgh. She has been writing Java code since 2002 and contributed to various types of applications such as experimental search engines, ERPs, track and trace, and banking. During her career, she has been a teacher, a team leader, software architect, DevOps professional, and software manager. She is a Spring-certified Professional, as defined by Pivotal, the makers of Spring Framework, Boot, and other tools, and considers Spring the best Java framework to work with. When she is not programming, she spends her time reading, blogging, learning to play piano, travelling, hiking, or biking.Chapter 1: An Introduction to Java- When every version was released, how were they called and what were the particularities- What is Java, how it is executed, what type of language it is and what is it good for-Chapter 2: Preparing your development environment- Installing Java, choosing an editor, choosing a build tool-Chapter 3: Getting your feet wet- Writing a simple program, compile and execute- Adding a dependency of somebody else’s code through dependencies of existing libraries- Mention best tools for java and most used frameworks like SpringChapter 4: Java syntax- what is a package, module- class- enums- interface ( private methods & default methods)- class, constructor, methods… etc- removal of _Chapter 5: Data Types- primitive, object types (emphasis on String, Collections, Calendar API)- String – compact Strings- Collections: Immutable collections, factory methods for Collections(JEP 269)- mention Generics- optional – enhancements- threads, futures – CompletableFuture (JEP 266)Chapter 6: Operators- unary, binary, ternary, logic, and the diamond operator (used in conjunction with anonymous inner classes)Chapter 7: Controlling the flow- if, loops- try catch (try with resources with managed variables)- recursionChapter 8: The Stream API- streams , optional to Stream, enhancementsChapter 9: Debugging , testing and documenting- what is a break point- loggers : unified JVM logging (JEP 264)- mocks and stubs- jmc, jps, jcmd – JDK utilities- The new Doclet API- the JShell Command Line Tool- accessing the process API- @Deprecated enhancements (JEP 277)Chapter 10: Making your application interactive- request data with System.in- Swing- Web applications (use the new HTTP client)- JavaFX UI (JEP 253)- Internationalization (JEP 267)Chapter 11: Writing files- storing data to files, reading it from them- serialization to Binary, XML, JSON, YML (JEP290)- playing with images – multi-resolution APIChapter 12: Publish-Subscribe Framework- reactive streamsChapter 13: Garbage Collection- JEP 214,248,271,291
Nature-Inspired Optimization Algorithms with Java
Gain insight into the world of nature-inspired optimization techniques and algorithms. This book will prepare you to apply different nature-inspired optimization techniques to solve problems using Java.You'll start with an introduction to the hidden algorithms that nature uses and find the approximate solutions to optimization problems. You'll then see how living creatures such as fish and birds are able to perform computation to solve specific optimization tasks. This book also covers various nature-inspired algorithms by reviewing code examples for each one followed by crisp and clear explanations of the algorithm using Java code. You'll examine the use of each algorithm in specific industry scenarios such as fleet scheduling in supply chain management, and shop floor management in industrial and manufacturing applications.Nature-Inspired Optimization Algorithms with Java is your pathway to understanding a variety of optimization problems that exist in various industries and domains and it will develop an ability to apply nature-inspired algorithms to find approximate solutions to them.WHAT YOU'LL LEARN* Study optimization and its problems* Examine nature-inspired algorithms such as Particle Swarm, Gray wolf, etc.* See how nature-inspired algorithms are being used to solve optimization problems* Use Java for solving the different nature-inspired algorithms with real-world examplesWHO THIS BOOK IS FORSoftware developers/architects who are looking to hone their skills in area of problem solving related to optimization with Java.Shashank Jain has been working in the IT industry for about 20 years, mainly in areas of cloud computing and distributed systems. He has a keen interest in virtualization techniques, security, and complex systems. Shashank has 32 software patents (many yet to be published) in the area of cloud computing, IoT, and machine learning. He is a speaker at multiple reputed cloud conferences. Shashank holds Sun, Microsoft, and Linux kernel certifications. He is also the author of the book "Linux Containers and Virtualization" published by Apress.1. Intro to Optimization Problems2. Nature Inspired Optimization Methods3. Birdsa. Particle swarm Optimizationb. Cuckoo search algorithmc. Pigeon inspired optimization4. Mammalsa. Grey wolf optimizerb. Lion Pride optimizerc. Cat swarm optimizationd. Bat algorithme. Monkey algorithm5. Insectsa. Ant colony optimizationb. Artificial Bee colonyc. Grasshopper optimizationd. Pigeon inspired algorithme. Social spider optimizationf. Mosquito host seeking optimization6. Sea Creaturesa. Whale optimization algorithmb. Artificial fish swarm algorithmc. Fish school search7. Simple Organismsa. Bacteria foraging optimizationb. Slime mould optimization
Introducing Qt 6
Get 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.Upon completing this book, you'll come away knowing how to build a C++ application from design to deployment, top to bottom. And, you'll have actual application and game examples that you can apply to your own work or hobby.WHAT YOU WILL LEARN* Learn to build your first applications and games using Qt 6 framework* Design, create, build and deploy your first Qt applications or games as finished products* Explore local storage integration in theory and practice* Cover deployment on Windows and on Android* Integrate with C++ language to leverage additional functionality* Dive into Custom Components and how to work with them* Explore different project structures and moreWHO THIS BOOK IS FORSoftware programmers, developers who are new to C++ or the Qt framework. Some prior programming experience though may be helpful.Ben Cöppicus is a software developer, trainer, and author specializing in native C++ development as well as some web development. He builds mostly web, mobile and desktop applications. It is his hope that his work and writing can help you learn new things, experience the wonderful world of programming and maybe make you a better programmer, developer as well. Part 11. IntroductionPart 2 - Content2. Setting up the Tools3. 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. Features11. Writing Diagrams in Qt12. Advanced Topics in Qt
Practical C++ Design
Go 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 architecture of the calculator; the observer pattern to design an event system; the singleton pattern as you design the calculator’s central data repository, a reusable stack; the command pattern to design a command system supporting unlimited undo/redo; the abstract factory pattern to build a cross-platform plugin infrastructure for extensibility; coroutines to implement a command line interface with a lazy tokenizer; and more.After reading and using this book, you’ll have begun the transition from C++ programmer to architect.WHAT YOU WILL LEARN* Read a specification document and translate it into a practical C++ design using some of the latest language features from C++20* Understand trade-offs in selecting between alternative design scenarios* Gain practical experience in applying design patterns to realistic development scenarios* Learn how to effectively use language elements of modern C++ to create a lasting design* Develop a complete C++ program from a blank canvas through to a fully functioning, cross platform application* Read, modify, and extend existing, high quality code* Learn the fundamentals of API design, including class, module, and plugin interfacesWHO THIS BOOK IS FORThe experienced C++ developer ready to take the next step to becoming a skilled C++ designer.ADAM B. SINGER graduated first in his class at the Georgia Institute of Technology in 1999 with a bachelors degree in chemical engineering. He subsequently attended the Massachusetts Institute of Technology on a National Defense, Science, and Engineering Graduate Fellowship. He graduated from MIT with a Ph.D. in chemical engineering in 2004 after defending his thesis titled Global Dynamic Optimization. Since graduation, Adam has been a member of the research and engineering staff at an oil and gas major, where he has worked in software development, design, and project management in areas such as optimization, reservoir simulation, decision support under uncertainty, basin modeling, well log modeling, and stratigraphy. He has also served on and chaired committees designing in-house training in the areas of technical software development and computational and applied mathematics. He currently holds a research supervisory position. Adam additionally held the title of adjunct assistant professor in the Department of Computational and Applied Mathematics at Rice University from 2007-2012. In both 2006 and 2007, he taught a graduate level course, CAAM 520, on computational science. The course focused on the design and implementation of high performance parallel programs.Preface (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.
Stylish F# 6
Why just get by in F# when you can program in style. This book goes beyond syntax and into design. It provides F# developers with best practices, guidance, and advice to write beautiful, maintainable, and correct code. This second edition, fully updated for .NET 6 and F# 6, includes all new coverage of anonymous records, the task {} computation expression, and the relationship between types and modules.Stylish F# 6 covers every design decision that a developer makes in constructing F# programs, helping you make the most educated and valuable design choices at every stage of code development. You will learn about the design of types and function signatures, the benefits of immutability, and the uses of partial function application. You will understand best practices for writing APIs to be used by F#, C#, and other languages. Each carefully vetted design choice is supported with compelling examples, illustrations, and rationales.WHAT YOU WILL LEARN* Know why, when, and how to code in immutable style* Use collection functions, piping, and function composition to build working software quickly* Be aware of the techniques available to bring error handling into the mainstream of program logic* Optimize F# code for maximum performance* Identify and implement opportunities to use function injection to improve program design* Appreciate the methods available to handle unknown data values* Understand asynchronous and parallel programming in F#, and how it differs from C# asynchronous programming* Exploit records and anonymous records as low-overhead, easily comparable containers for structured dataWHO THIS BOOK IS FORAny developer who writes F# code and wants to write it betterKIT EASON is a software developer and educator with more than 20 years of experience. He has been programming in F# since 2011 and is employed at Perpetuum Ltd., working on an extensive network of energy-harvesting vibration sensors fitted to railway rolling stock and infrastructure. Kit is an avid F# user who is passionate about teaching others. He has contributed to several publications, including Apress books Beginning F# and F# Deep Dives. He often teaches on the topic of F# and his popular videos appear on Udemy and Pluralsight. Chapter 1: The Sense of StyleChapter 2: Designing Functions Using TypesChapter 3: Missing DataChapter 4: Working Effectively with Collection FunctionsChapter 5: Immutability and MutationChapter 6: Pattern MatchingChapter 7: Record TypesChapter 8: ClassesChapter 9: Programming With FunctionsChapter 10: Asynchronous and Parallel ProgrammingChapter 11: Railway Oriented ProgrammingChapter 12: PerformanceChapter 13: Layout and NamingChapter 14: Summary
Natural Language Processing Projects
Leverage machine learning and deep learning techniques to build fully-fledged natural language processing (NLP) projects. Projects throughout this book grow in complexity and showcase methodologies, optimizing tips, and tricks to solve various business problems. You will use modern Python libraries and algorithms to build end-to-end NLP projects.The book starts with an overview of natural language processing (NLP) and artificial intelligence to provide a quick refresher on algorithms. Next, it covers end-to-end NLP projects beginning with traditional algorithms and projects such as customer review sentiment and emotion detection, topic modeling, and document clustering. From there, it delves into e-commerce related projects such as product categorization using the description of the product, a search engine to retrieve the relevant content, and a content-based recommendation system to enhance user experience. Moving forward, it explains how to build systems to find similar sentences using contextual embedding, summarizing huge documents using recurrent neural networks (RNN), automatic word suggestion using long short-term memory networks (LSTM), and how to build a chatbot using transfer learning. It concludes with an exploration of next-generation AI and algorithms in the research space.By the end of this book, you will have the knowledge needed to solve various business problems using NLP techniques.WHAT YOU WILL LEARN* Implement full-fledged intelligent NLP applications with Python* Translate real-world business problem on text data with NLP techniques* Leverage machine learning and deep learning techniques to perform smart language processing* Gain hands-on experience implementing end-to-end search engine information retrieval, text summarization, chatbots, text generation, document clustering and product classification, and moreWHO THIS BOOK IS FORData scientists, machine learning engineers, and deep learning professionals looking to build natural language applications using PythonAKSHAY R KULKARNIis a renowned AI and machine learning (ML) evangelist and thought leader. He has consulted with Fortune 500 and global enterprises to drive AI and data science-led strategic transformations. Akshay has experience building and scaling AI and ML businesses and creating significant impact. He is currently Manager of Data Science & AI at Publicis Sapient on their core data science and AI team where he is part of strategy and transformation interventions through AI. He manages high-priority growth initiatives around data science and works on AI engagements by applying state-of-the-art techniques. He is a Google Developers Expert–Machine Learning, published author of books on NLP and deep learning, and a regular speaker at major AI and data science conferences (including Strata, O’Reilly AI Conf, and GIDS). Akshay is a visiting faculty member for some of the top graduate institutes in India. In 2019, he was featured as one of Top40 under 40 Data Scientists in India. In his spare time, he enjoys reading, writing, and coding, and help aspiring data scientists. He lives in Bangalore with his family.ADARSHA SHIVANANDA is a senior data scientist on Indegene's Product and Technology team where he works on building machine learning and artificial intelligence (AI) capabilities for pharma products. He aims to build a pool of exceptional data scientists within and outside of the organization to solve problems through training programs, and always wants to stay ahead of the curve. Previously, he worked with Tredence Analytics and IQVIA. Adarsha has worked extensively in the pharma, healthcare, retail, and marketing domains. He lives in Bangalore and loves to read and teach data science.ANOOSH KULKARNI is a data scientist and senior consultant focused on artificial intelligence (AI). He has worked with global clients across multiple domains and helped them solve their business problems using machine learning (ML), natural language processing (NLP), and deep learning. Presently, he is working with Subex AI labs. Previously, he was a data scientist at one of the leading ecommerce companies in the UAE. Anoosh is passionate about guiding and mentoring people in their data science journey. He leads data science/machine learning meet ups in Bangalore and helps aspiring data scientists navigate their careers. He also conducts ML/AI workshops at universities and is actively involved in conducting webinars, talks, and sessions on AI and data science. He lives in Bangalore with his family. Chapter 1: Natural Language Processing & Artificial Intelligence OverviewChapter Goal: This is an introductory chapter. This chapter provides a quick refresher of the topics to be covered in this book. Since this book teaches projects surrounding a specific area of technology, we will provide a brief introduction to the key concepts required for these projects. We will not be working on a specific project, rather discuss some important concepts without going into details. The depth on each of these topics will be covered in the specific chaptersNo of pages: 25Sub - Topics:1. Artificial intelligence paradigm2. NLP and AI life cycle3. NLP concepts (TF-IDF, word embeddings, many more)4. Machine learning concepts (supervised learning, classification, unsupervised learning)5. Deep learning concepts (CNN, RNN, LSTM)Chapter 2: Product360 - Sentiment, Emotion & Trend Capturing SystemChapter Goal: Sentiment analysis involves finding the polarity of a sentence and labels it as positive, negative or neutral. Emotion detection involves identifying emotions(sad, anger, happy, etc) from the sentences. Data is extracted from social media like Twitter, Facebook etc. and Ecommerce website, processed and analyzed using different NLP techniques will provide a 360 degree view of that product which enables better decision making. This chapter introduces sentiment analysis to the reader and the various techniques that can be used to analyze text. We will apply sentiment, emotion and trend analysis on reviews data for any E-commerce website like Amazon, Zomato, and IMDb, etc. which contains millions of customer reviews and star ratings. For this task, we will use Python libraries such as Vader, Textblob, etc.No of pages: 30Sub - Topics1. Text mining and various available libraries.2. Data preprocessing.3. Data cleaning tricks, optimized feature engineering4. EDA5. Sentiment analysis6. Emotion and trend analysisChapter 3: TED Talks Segmentation & Topics Extraction Using Machine LearningChapter Goal: Document clustering is an unsupervised learning process for grouping documents. For example, there are number of e-books and they have to be grouped to build a structure around them saves time while finding the books. Articles grouping, product clustering are the other few examples. Once we identify the clusters, it is important to understand the properties of clusters. So, Topic modeling is performed to extract topics from a set of documents and articles to understand the content of the documents using keywords and be able to tag the articles or documents using those topics.In this chapter will see how to group TED talks based on description using various clustering techniques like K-Means and Hierarchical clustering. Then we will perform topic modeling using Latent Dirichlet Allocation (LDA) to understand what defines each cluster. Important libraries include Gensim, NLTK, Scikit-learn and word2vec for this problem. We will use over 100k articles from different American publications.No of pages: 30Sub - Topics1. Data understanding and pre-processing2. Computing TF-IDF3. K-Means and hierarchical clustering4. Evaluation and visualization5. Topic modeling using Latent Dirichlet AllocationChapter 4: Enhancing E-commerce Through Advanced Search Engine and Recommendation SystemChapter Goal: An information retrieval system will search product descriptions based on a search query text and gives the results. Search engines are the most common and best use case of information retrieval models. The concept of information retrieval started from a string or word comparison, but it won’t be accurate as it doesn’t capture semantics. Advanced deep learning techniques made information retrieval work more accurately.Recommender systems are everywhere and used to create a personalized recommendations to increase the user experience. There are many types of recommender systems from collaborative filtering to graph-based. But the one dependent on Natural language processing is content-based recommender systems. It leverages the content of the item or the demographics of the user to recommend and this information is purely in the form of text. In this chapter, we will use advanced deep learning and word embedding techniques to search and recommend items/products to customers and libraries like SciKit-learn, NLTK, Keras, Word2vec, etc. We will use Flipkart e-commerce sample data which has the product name and its description.No of pages: 30Sub - Topics:1. Information retrieval, word embeddings for IR, similarity scoring.2. Content-based recommendation systems working3. Data understanding and preprocessing4. Search engine using word embeddings5. Recommender system using KNNChapter 5: E-Commerce Product Categorization Model Using Deep learningChapter Goal: Most of the time, classification problems won’t be binary rather they will be multiclass. For example, categorizing the retail products based on the description, categorizing the call center complaints, etc. Complexity increases as the number of classes increases. Let’s solve this problem by using deep learning techniques. We leverage deep neural networks using the Keras library. Feature engineering techniques like TF-IDF and word embeddings are considered. We will use product description data for an E-commerce company to categorize the products.No of pages: 25Sub - Topics:1. Text pre-processing2. Text to features using TF-IDF and word embeddings3. Multi-class classification using deep neural networks4. Parameter tuning and optimizationChapter 6: Movie Genre TaggingChapter Goal: Categorizing movies into genres is one of the classic AI problems. Online movie booking platforms, review websites like IMDB would tag movies into respective genres. The genre can be action, adventure, comedy, romance and so on.Our goal here is to tag possible movie genres given the description of the movie. Machine/model has to predict all possible classes(genres) the movie would belong to. We have solved simple multi-class classification but, in this chapter, let's explore how to solve a multi-label learning and classification problem.No of pages: 25Sub - Topics:1. Text processing2. Data preparation for modeling3. Text to features4. Multi-label classification using different algorithms5. Parameter tuning and evaluationChapter 7: Content Recommendation for the Marketing CampaignChapter Goal: A content recommendation engine collects and analyzes data based on users' behavior on marketing content. This data is then used to offer personalized and relevant marketing materials. We can tailor the subjects of the emails based on historical interactions. We will use deep learning techniques using Keras along with word embeddings.No of pages: 25Sub - Topics: 1. Why content recommendation2. Feature engineering3. Open rate to find the right contentChapter 8: Quora Question Pair SimilarityChapter Goal: Over 100 million people visit Quora every month, so it's no surprise that many people ask similarly worded questions. Multiple questions with the same intent can cause seekers to spend more time finding the best answer to their question and make writers feel they need to answer multiple versions of the same question. The goal of this chapter is to predict which of the provided pairs of questions contain two questions with the same meaning using advanced deep learning techniques. Keras will be used to find the similarity score.No of pages: 25Sub - Topics:1. Why predicting the similar questions?2. Text pre processing3. Word embeddings4. Finding similar questionsChapter 9: Resume Parsing & Shortlisting with Machine LearningChapter Goal: In the recruitment industry, millions of people are uploading resumes and applying for jobs every day on thousands of employment platforms. Businesses have their openings listed on these platforms and job seekers come to apply. Every business has a dedicated recruitment team that manually goes through the applicant's resumes and extracts relevant data to see if they are a fit. To automate this task, this project tries to converts an unstructured form of resume data into a structured format. It's a model that analyses and extracts resume data, returns the machine-readable output and ranks the top resume’s that are best match to the given job description. This helps to store and analyze data automatically.No of pages: 25Sub - Topics:1. Resume parsing using various NLP techniques2. NER3. Shortlisting and ranking resumesChapter 10: Building Chatbot Using Transfer learningChapter Goal: Question Answering (QA) System - also termed as “Chatbot” is very useful as most of the deep learning-related problems can be modeled as a question answering problem. Consequently, the field is one of the most researched fields in computer science today. The last few years have seen considerable developments and improvement in the state of the art, much of which can be credited to the upcoming of deep learning. In this chapter, we will build end to end QA system using NLTK, modern deep learning algorithms, and transfer learning.No of pages: 25Sub - Topics:1. Q&A system explained2. Q&A architecture3. Natural Language Understanding4. Learn possible approaches and algorithms5. How to use transfer learning6. Fine Tuning and optimizing the network7. End to end implementation and evaluationChapter 11: Summarization System Using RNNChapter Goal: With the ever-growing data, reading the whole document is just time-consuming. We need to summarize the huge text corpus to make life easier. Text summarization is the process of creating a short summary of a longer document with accurate meaning. It’s widely used in headlines generation, summarizing the reviews, etc. There are many approaches to solve this problem like feature-based, graph-based, using sentence embeddings, etc. Abstractive methods like deep learning and reinforcement learning are providing excellent results since it generates an entirely new sentence which captures the meaning of source document. In this chapter, we will discuss all these Extractive and Abstractive methods to summarize the text. We will be using NLTK, Gensim, SciKit-learn, and Keras libraries.No of pages: 30Sub - Topics:1. Text summarization using Extractive methods2. Abstractive methods3. Text summarization using deep learning4. Text summarization using reinforcement learningChapter 12: Automated Text Generation Using LSTM and EncodersChapter Goal: Text Generation is a type of Language Modelling problem. Language Modelling is the core problem for several natural language processing tasks such as speech to text, conversational system, and text summarization. A trained language model learns the likelihood of occurrence of a word based on the previous sequence of words used in the text. Language models can be operated at the character level, n-gram level, sentence level, or even paragraph level. In this chapter, we will create a language model for generating natural language text by implement and training state-of-the-art recurrent neural network. We will use the Python programming language for this purpose. The objective of this model is to generate new text, given that some input text is present. We will start building the architecture. We will be using NLTK, Gensim, SciKit-learn and Keras libraries.No of pages: 25Sub - Topics: 1. Text generation concepts and application2. Text generation architecture3. Text preprocessing and feature engineering4. Building the LSTM network model5. Seq2Seq modelsChapter 13: Future of NLP & Next-Gen Artificial IntelligenceChapter Goal: In this chapter, let's summarize what we learned so far in this book. We started from basics, traditional tasks to advanced text generation problems. We implemented and explored how deep learning is perfect for natural language understanding. We learned classification, information retrieval systems, Q&A systems, and also text generation. We will also explore why deep learning and other next-gen AI algorithms like GANS, Capsule networks, Differentiable Neural Computers, Unsupervised/Semi-supervised Deep Learning, Attention Networks, Transfer Learning, Deep Reinforcement Learning, Meta-Learning, is uniquely suited to NLP or their short comes, and how these algorithms would evolve and give state-of-the-art results in a slew of tasks under NLU and NLG.No of pages: 12Sub - Topics:1. What did we learn2. Future of NLP3. Next-Gen learning algorithms for NLP4. Deep reinforcement learning5. What are the current challenges in NLP?6. Research directions to solve the challenges7. Current research in the NLP world
Python Unit Test Automation
Learn how to automate unit tests of Python 3 with automation libraries, such as doctest, unittest, nose, nose2, pytest, and selenium. This book explores important concepts in software test automation and demonstrates how to automate, organize, and execute unit tests with Python. It also introduces readers to the concepts of web browser automation and logging.This new edition starts with an introduction to Python 3. Next, it covers doctest and pydoc. This is followed by a discussion on unittest, a framework that comes packaged with Python 3 itself. There is a dedicated section on creating test suites, followed by an explanation of how nose2 provides automatic test module discovery. Moving forward, you will learn about pytest, the most popular third-party library and testrunner for Python. You will see how to write and execute tests with pytest. You’ll also learn to discover tests automatically with pytest.This edition features two brand new chapters, the first of which focuses on the basics of web browser automation with Selenium. You’ll learn how to use Selenium with unittest to write test cases for browser automation and use the Selenium IDE with web browsers such as Chrome and Firefox. You’ll then explore logging frameworks such as Python’s built-in logger and the third-party framework loguru.The book concludes with an exploration of test-driven development with pytest, during which you will execute a small project using TDD methodology.WHAT YOU WILL LEARN* Start testing with doctest and unittest* Understand the idea of unit testing* Get started with nose 2 and pytest* Learn how to use logger and loguru* Work with Selenium and test driven developmentWHO THIS BOOK IS FORPython developers, software testers, open source enthusiasts, and contributors to the Python community. Ashwin Pajankar holds a Master of Technology from IIIT Hyderabad, and has over 25 years of programming experience. He started his journey in programming and electronics with BASIC programming language and is now proficient in Assembly programming, C, C++, Java, Shell Scripting, and Python. Other technical experience includes single board computers such as Raspberry Pi and Banana Pro, and Arduino. He is currently a freelance online instructor teaching programming bootcamps to more than 60,000 students from tech companies and colleges. His Youtube channel has an audience of 10000 subscribers and he has published more than 15 books on programming and electronics with many international publications.Chapter 1: Introduction to PythonChapter Goal: Brief intro into Python 3No of pagesSub -Topics1. History of Python2. Features3. Python 34. Installation5. Running a Python program6. IDEsChapter 2: GettingSstarted with Unit TestingChapter Goal: Brief acquaintance with the subject of the book and some hands onNo of pages:Sub - Topics:1. Software Testing concepts2. Docstrings3. pydoc4. DoctestChapter 3: UnittestChapter Goal: Getting to understand the Unittest frameworkNo of pages:Sub - Topics:1. xUnit2. Using unittest3. Test discovery4. Coding conventions for unittest5. Assertions in unittest6. Other useful methods7. Failing a test8. Advanced functionalitya) More command line optionsb) Test suitec) AssertRaisesWarnChapter 4: Nose and Nose 2Chapter Goal: Concepts of Nose and Nose 2No of pages:Sub - Topics:1. Introduction to nose2. Fixtures3. Testing Tools4. Reports5. Running unittests and doctests6. Advantages and disadvantages7. Introduction to nose 28. Advanced topics in nose 2a) Running tests and conventionsb) Parameterized testsc) Generating reportChapter 5: pytestChapter Goal: work with pytest1. Introduction to pytest2. Fixtures3. Command line optionsChapter 6: TestifyChapter Goal: work with testify1. Fixtures2. Advanced featuresChapter 7: Logging in PythonChapter Goal: work with logging1. Logger2. LoguruChapter 8: Additional TopicsChapter Goal: work with testify1. Naming conventions2. TDD with Python3. Selenium with pytest and logger
More Java 17
Work with the essential and advanced features of the Java 17 release. This book covers features such as annotations, reflection, and generics. These topics are then complemented by details of how to use lambda expressions, allowing you to build powerful and efficient Java programs. Furthermore, added to this edition you'll find topics on network programming, Java RMI, the process API, and custom runtime images. The authors provide a multitude of diagrams and complete programs to help you visualize and better understand the topics covered in this book.More Java 17, Third Edition starts with a series of chapters on the essential language features provided by Java before moving on to Java module development and packaging, and improved interop with other languages. After reading this book, you'll have the know-how of a professional Java programmer and be able to tackle most projects with confidence.This book's source code can be accessed at github.com/Apress/more-java-17.WHAT YOU WILL LEARN* Use essential and advanced features of the Java language* Code Java annotations* Work with reflection and generics* Manage streams with the Stream APIWHO THIS BOOK IS FORThose new to Java programming who are continuing the Java learning journey; it is recommended that you read an introductory Java programming book first, such as Java 17 for Absolute Beginners, from Apress.KISHORI SHARAN has earned a master of science in computer information systems degree from Troy State University, Alabama. He is a Sun Certified Java 2 programmer. He has vast experience in providing training to professional developers in Java, JSP, EJB, and web technology. He possesses over ten years of experience in implementing enterprise-level Java applications.PETER SPÄTH graduated in 2002 as a physicist and soon afterward became an IT consultant, mainly for Java-related projects. In 2016, he decided to concentrate on writing books on various aspects, but with a main focus on software development. With two books about graphics and sound processing, three books on Android app development, and a beginner’s book on Jakarta EE development, the author continues his effort in writing software development-related literature.1. Annotations2. Inner Classes3. Reflection4. Generics5. Lambda Expressions6. Threads7. Input Output8. Working with Archive Files9. New Input Output NIO10. New Input Output 2.011. Garbage Collection12. Collections13. Streams14. Implementing Services15. The Module API16. Breaking Module Encapsulation17. Reactive Streams18. Stack Walking19. Network Programming20. JDBC API21. Java Remote Method Invocation22. Java Native Interface23. Process API24. Packaging Modules25. Custom Runtime Images
API Marketplace Engineering
This is your hands-on guide to designing, building, and operating an API Marketplace to allow your organization to expose internal services and customer data securely for use by external developers. The book shows the mutual nature of a relationship in which organizations benefit from revenue and the reach of a new digital channel and third-party developers benefit from leveraging APIs to build unique applications.Providing open access is a regulatory requirement in some sectors, such as financial services, and this book helps you to build a platform to comply with regulatory requirements while at the same time encouraging and supporting use by external development teams. The book provides the blueprints for assembling teams and systems to build and support an API ecosystem. It offers insight into how the Marketplace can be constructed in a way to allow agility and flexibility to meet aggressive startup developer timelines while balancing established enterprise requirements of stability, reliability, and governance. The goal of this book is to provide engineering teams with a view of the operational requirements and how to meet and exceed these by establishing foundational elements at design time.An API Marketplace presents a unique challenge as organizations have to share internal capability and customer data with external developers. Security practices and industry standards are contrasted and discussed in this book. Practical approaches are provided to build and support a third-party developer ecosystem, manage sandbox environments hosting APIs of varying complexities, and cover monetization strategies that are yielding positive results to achieve self-sustainability.WHAT YOU WILL LEARN* Understand the motivation and objectives for an API economy* Build key technical components of an API platform* Comply with regulatory requirements such as Open Banking* Secure APIs and customer data from external attack* Deliver APIs quickly while satisfying governance requirements* Get insight into a real-world API Marketplace implementationWHO THIS BOOK IS FORSolution architects, API product owners, delivery and development leads, and developers; anyone developing APIs for consumption by external business partners; API developers who want more insight into regulatory complianceRENNAY DORASAMY has spent the last 20 years in various technology roles, ranging from development to operations to architecture, across a number of industries. He has worked in telecoms, with government, and most recently in financial services. He has considerable hands-on integration experience working on middleware platforms from C-based messaging to Java Enterprise Edition. He is experienced in both core enterprise and digital contexts. As a full-stack engineer, he is intimately familiar with technologies such as containerization, cloud, and serverless technology for building and deploying mission-critical solutions. He is currently the Engineering Lead of an API Marketplace implementation, the first of its kind in financial services on the African continent. 1. API Engineering2. Regulation3. Consumption4. Monetization5. Platform Architecture6. Security7. API Design8. API Development9. Sandbox10. API Operations11. Conclusion