Programmierung
Einführung in JavaFX/OpenJFX
Das JavaFX-Framework gibt es schon seit einigen Jahren, hat aber mit den ersten Versionen fast nur noch den Namen gemeinsam. Seit der Version 2 hat JavaFX jedoch einen festen und ausgereiften Stand erreicht und ist mittlerweile die aktuelle Technologie im Java-Umfeld, um leistungsfähige und moderne grafische Benutzeroberflächen (GUI) erstellen zu können. Dieses Buch stellt Ihnen dazu eine Vielzahl an Widgets und Komponenten samt dem JavaFX-API vor. Es zeigt Ihnen auch, wie Sie mit Hilfe des APIs sowohl aus Java heraus, aber auch über einen XML-basierenden Ansatz (FXML) samt einem visuellen Designer-Tool (Scene Builder) grafische User-Interfaces erstellen können. So können Sie sogar ohne Java-Kenntnisse eine leistungsfähige und moderne GUI erstellen, aber auch Kenntnisse in anderen GUI-Technologien wie Swing übertragen und sogar diese Komponenten in JavaFX integrieren. RALPH STEYER ist Diplom-Mathematiker und seit 1996 im Bereich EDV-Schulung, Programmierung und Beratung selbstständig. Seine Spezialgebiete sind die Internetprogrammierung und OOP. Das Umfeld von JavaFX - Grundlagen zu Java - Einführung und Grundlagen zu JavaFX - JavaFX-Applikationen mit FXML - Java-Oberflächen mit XML und Web-Technologien - Der Scene Builder - Java-Oberflächen mit der Maus erzeugen - JavaFX UI
Beginning PyQt
Learn GUI application development from the ground up by building simple projects that teach the fundamentals of using PyQt6. This 2nd edition includes updated code, programs, and new chapters to get you started using the newest version. Taking a practical approach, each chapter will gradually teach more advanced and diverse concepts to aid you in designing and customizing interesting and professional applications.You'll start by learning important concepts related to GUI development, and then jump right into building different and exciting projects in every chapter. Along the way, you’ll discover new widgets, layouts, and other concepts that will help you to build better UIs. You'll also construct more elaborate GUIs, covering topics that include storing data using the clipboard, graphics and animation, support for SQL databases, multithreading applications, and building modern-looking interfaces.Using this knowledge, you’ll be able to build a photo editor, games, a text editor, a working web browser, and an assortment of other GUIs. In the end, this book will guide you through the process of creating UIs to help you bring your own ideas to life. Find out what you need to begin making your own applications with PyQt!WHAT YOU'LL LEARN* Develop cross-platform UIs with PyQt and Python* Use PyQt’s many widgets and apply them by building real applications* Build larger applications through a step-by-step approach and break the code into smaller chunks for deeper understanding* Work with more complex applications in PyQt, covering SQL databases, multithreading, web browsers, and more* Create modern-looking UIs with Qt Quick and QtQml using the latest version of PyQtWHO THIS BOOK IS FORPython developers who are looking to begin creating user interfaces and want to utilize the latest version of PyQt to gets started. Having prior knowledge of PyQt or other Python UI toolkits is not necessary to begin using this book.JOSHUA WILLMAN is a software engineer with more than 12 years of experience developing applications in mainly Python and C++. His career has allowed him to participate in many different fields, from robotics, machine learning, and computer vision, to UI development, game development, and more. His first experience with PyQt was building an interface for simplifying the labeling process of datasets for machine learning. Ever since then, he’s been hooked!In recent years, his passion for programming and all things visual has allowed him to participate in numerous projects. These include designing educational courses for mobile robotics and computer vision using Arduino and Raspberry Pi, building GUI applications, and working as a solo indie game developer. He currently works as a robotics engineer, a technical writer, and a content creator (learning web development in his spare time in order to build his own platform, redhuli.io). When he’s not working, he enjoys tinkering on robotics projects and spending time with his wonderful wife and daughter.He is also the author of two books with Apress:• Beginning PyQt: A Hands-on Approach to GUI Programming (1st Edition)• Modern PyQt: Create GUI Applications for Project Management, Computer Vision, and Data AnalysisBEGINNING PYQT (2E)Chapter 1: Getting Started with PyQtChapter 2: Building a Simple GUIChapter 3: Adding More Functionality with WidgetsChapter 4: Learning About Layout ManagementChapter 5: Menus, Toolbars, and MoreChapter 6: Styling Your GUIsChapter 7: Handling Events in PyQtChapter 8: Creating GUIs with Qt DesignerChapter 9: Working with the ClipboardChapter 10: Presenting Data in PyQtChapter 11: Graphics and Animation in PyQTChapter 12: Creating Custom WidgetsChapter 13: Working with QT QuickChapter 14: Introduction to Handling DatabasesChapter 15: Managing ThreadsChapter 16: Extra ProjectsAppendix: Reference Guide for PyQT6
Gamedesign für Dummies Junior
Spiele zu entwickeln ist dein Traum? Worauf wartest du? Mit der Programmiersprache Scratch ist es sehr einfach, die Zutaten für ein Spiel zu erstellen. Mit Scratch kannst du zeichnen, animieren, musizieren, programmieren, Sounds aufnehmen und Texte als Sprache ausgeben. Wie du dann daraus ein cooles Spiel machst, erklärt dir dieses Buch. In den Kapiteln werden verschiedene Projekte beschrieben, die du nur nachmachen musst. Nichts kann schief gehen. Schritt für Schritt steigst du immer tiefer ins Programmieren und Designen ein. Und je mehr Tipps und Tricks du kennst, desto einfacher kannst du deine eigenen Ideen umsetzen.Bestens geeignet für Kinder und Jugendliche ab 10 Jahren. Johanna Janiszewski ist professionelle Spieleentwicklerin und Game Designerin. Sie führt ihr eigenes Spielestudio "Tiny Crocodile Studios" in Berlin und entwickelte das Kinderspiel "Monkey Swag", welches 2018 den Deutschen Computerspielpreis als bestes Kinderspiel gewann. Für den Verband der deutschen Spielebranche "game" ist sie Regionalvertreterin für Berlin-Brandenburg. Daneben hält sie Workshops zur Spieleentwicklung für alle Altersgruppen und ist Autorin von "Unity für Dummies".Lisa Ihde studiert im Master "IT-Systems Engineering" am Hasso-Plattner-Institut Potsdam. Nebenbei leitet sie (Spiele-)Programmierworkshops für Kinder und Jugendliche und hat international an Game Jams teilgenommen. Sie war Jurorin beim Deutschen Multimediapreis, wo auch Scratch-Spiele von Kindern ausgezeichnet werden. Um die Diversität in der Spielebranche zu stärken, entwickelte sie mit Frauen aus sechs Ländern digitale Spiele - gefördert durchs Goethe-Institut. Sie ist Autorin von "Meine eigene Homepage für Dummies Junior" und von "3D-Grafiken designen und animieren für Dummies Junior".Wilfried Elmenreich ist Professor an der Alpen-Adria-Universität Klagenfurt, wo er im Masterstudiengang "Game Studies and Engineering" Lehrveranstaltungen zu Computerspielproduktion und Brettspieldesign abhält. Er ist Autor von Anleitungen im deutschsprachigen Scratch-Wiki und hat auf der Spieleplattform itch.io einen Game Jam für Scratch-Spiele organisiert. Zudem gibt er für Jugendliche gerne Kurse zur Spieleentwicklung mit Scratch und ist Autor mehrerer Bücher.EINFÜHRUNG 8Hallo, zukünftige Gamedesign-Profis! 8Über Gamedesign 8Über Scratch 9Über dieses Buch 10Über dich 10Über die Symbole, die wir in diesem Buch verwenden 11KAPITEL 1: AUF DIE PLÄTZE 13Erstelle deinen Scratch-Account 13Erste Schritte mit Scratch – die Benutzeroberfläche 14Der Zaubertrick 16Die Spielfigur 17Der Soundeffekt 20Das Hintergrundbild 21Fühler, wechsle dich! 23Ordnung ist das halbe Leben 26Das Projekt speichern 26Das Projekt laden 26Dein Projekt veröffentlichen 27Andere Projekte entdecken 28Zauber-Fangspiel 30KAPITEL 2: SPAẞ BEIM FENSTERPUTZEN 35Das Projekt vorbereiten 36Einen Fleck zeichnen 36Den Countdown für den Spielstart zeichnen 37Die Auswertung für das Spielende zeichnen 40Die Figuren zurechtrücken 40Jubelschreie finden 42Variablen anlegen 43Die Variablen zurechtrücken 46Mehr Möglichkeiten dank Erweiterungen 47Das Spiel programmieren 483 2 1 Los! 48Alles vollklecksen 51Die Flecken wegwischen 54Spielende 56Eine neue Bestzeit erreichen 57Ideen zum Gamedesign 59Spielspaß durch Zahlen 59Balancing-Werte 60Die Spielidee verändern 61KAPITEL 3: HÖHLENEXPEDITION 63Die Spielfigur 64Steuerung für die Spielfigur 65Animieren der Spielfigur 69Begrenzen der Spielfigurbewegung 71Helm hinzufügen 72Die Höhle 73Vorsicht, Stalaktiten! 75Die Stalaktiten spüren 80Helme zählen 81Betreten der nächsten Höhle 83Neue Höhlenhintergründe für die Bühne 84Höhlen mitzählen und Spiel mit der Zeit schwieriger machen 85Game Over! 86Ideen zum Gamedesign 87Balancing 87Gehen oder Rennen? 88Noch mehr Balancingwerte 90Zugänglichkeit und Spielspaß 91Was mache ich hier eigentlich?! 92Die Spielmechanik verändern 92Geräusche hinzufügen 93Nett sein oder auslachen? 93KAPITEL 4: VIRTUELLES HAUSTIER 95Das Projekt vorbereiten 96Hast du ʽnen Vogel? 96Zeichne den Vogel 96Entferne den Hintergrund 97Zeichne das Hintergrundbild für die Bühne 98Wir haben da etwas vorbereitet 100Das Bühnenbild hochladen 100Die Vogelbilder hochladen 101Den Vogel zurechtrücken 102Es dem Vogel gemütlich machen 105Die Objekte zurechtrücken 106Geheime Orte einfügen 107Dem Vogel durch Programmieren »Leben« einhauchen 108Den Vogel kitzeln 108Eigene Blöcke für eigene Ideen 110Dem Vogel beibringen zu schlafen 111Dem Vogel das Fliegen beibringen 113Dem Vogel noch mehr beibringen 114Den Vogel selbst entscheiden lassen 118Musik programmieren und kombinieren 119Ideen zum Gamedesign 121Der Vogelsimulator 121Selbst kreativ werden 122Ein kleines Spiel hinzufügen 123KAPITEL 5: NOTARZT, EIN 3D-PROJEKT! 126Projekt anlegen und Bühnenbild zeichnen 128Straße 129Unser Fahrzeug 133Berge und Himmel am Horizont einbauen 136Die Straße verschiebbar machen 138Andere Fahrzeuge hinzufügen 139Der Unfall 142Ideen zum Gamedesign 145Punkte sammeln 145Das Fahrzeug ändern 146Spurwechsel des anderen Fahrzeugs 148KAPITEL 6: WELTRAUM-ABENTEUER 149Springen und Laufen 150Vorbereitung des Spiels 150Dein Hunde-Astronaut 150Der Weltraum – unendliche Weiten 153Die Plattformen 154Hindernisse 155Sterne 157Steuerung deines Astronauts 159Starteinstellungen 159Lauf, Hund, Lauf! 161Hoch hinaus! 164Schwerkraft 165Plattform-Berührung 168Berührung von Hindernissen und Fall in Schluchten 170Ordentlich punkten! 171Sterne erzeugen 171Sterne sammeln 173Von Level zu Level 174Bereite die Level vor 174Nächstes Level aufrufen 176Ideen zum Gamedesign 178Tipps fürs Leveldesign 178Ziel und Endsequenz einbauen 179KAPITEL 7: EIGENE PROJEKTE ENTWICKELN 183Eine Idee entwickeln 184Nutze deine Erfahrung 184Der Zufall kann dir helfen 184Andere fragen 185Gamedesign-Fragenbeantworten 185Dein Spiel entwickeln 188Fange klein an 188Die »Einkaufsliste« schreiben 189Bilder und Geräusche von anderen 189Testen, testen und noch mehr testen 191Selber testen 191Mit anderen testen 191Macht’s Spaß? 191Wenn mal etwas schiefgeht 192Detektivarbeit 192Mach mal Pause 193Einen Schritt zurückgehen 194Fehler passieren auch den Besten 194Mache Sicherheitskopien 194Man lernt nie aus 195Noch mehr Anleitungen 195Remixen, Verändern, Lernen 196Andere um Hilfe bitten 197Das Scratch-Wiki 198Dein Spiel veröffentlichen 198Aufmerksamkeit für das Spiel bekommen 199Zwei Tipps zum Schluss 200Bleib dran 200Niemand ist perfekt 200Zum Wiederfinden 201Über die Autoren 205
The Definitive Guide to Jakarta Faces in Jakarta EE 10
Learn and master the new features in the new Eclipse Jakarta Faces (formerly JavaServer Faces or JSF) web framework in this definitive guide written by two of the driving forces of the Faces project and the co-creators of the OmniFaces library. Authors Bauke Scholtz and Arjan Tijms take you through real-world examples that demonstrate how these new features are used with other APIs in Jakarta EE. You’ll see the new and exciting ways Jakarta Faces applications can use to communicate between a client and a server, such as using WebSockets, invoking bean methods directly from Ajax, executing client-side JavaScript when Ajax calls complete, and moreAlong the way you’ll broaden your knowledge of Faces components and web APIs best practices, and learn a great deal about the internals of Faces and the design decisions that have been made when building the Faces API. For example, you’ll see what artefacts are now CDI injectable, how CDI changed Faces internally, and what some of the caveats are when working with the CDI versions of a Faces artefact.Furthermore, you'll build an example application from scratch. After reading The Definitive Guide to Jakarta Faces in Jakarta EE 10, you'll be ready to build your own efficient and secure web applications.WHAT YOU WILL LEARN* Leverage the new features in Jakarta Faces in Jakarta EE in your existing applications* Integrate Faces and CDI* Use the brand new Component Search Expression framework, which enables you to more easily locate components from your template* Extend the Component Search Expression framework with your own search operators* Work with the different ways of mapping requests to Faces, make your application use extension-less URLs, and programmatically inspect which resources are present in your application* Master the best practices for web application development and see which are obsoleteWHO THIS BOOK IS FORExisting JSF or Java developers who need to create a web UI. No prior knowledge of Faces is required, but the book does skew towards the more experienced developer. Concepts such as dependency injection and MVC are assumed to be known, as is a general knowledge about HTML, HTTP and other web standards.BAUKE SCHOLTZ is an Oracle Java Champion, a member of the JSF 2.3 Expert Group and the main creator of the JSF helper library OmniFaces. He is on the internet more commonly known as BalusC who is among the top users and contributors on Stack Overflow. Bauke has integrated several OmniFaces solutions into JSF 2.3. He is a web application specialist and consults or has consulted for these Mercury1 Limited, MyTutor, Nava Finance, LinkPizza, ZEEF, M4N/Zanox, ITCA, RDC and more clients from fintech, affiliate marketing, social media and more as part of his 17 years of experience. This book offers Bauke the opportunity to go into depth as to answering most frequently asked questions and correctly solving most commonly encountered problems while using JSF.ARJAN TIJMS works for Payara Services Ltd and is a JSF (JSR 372) and Security API (JSR 375) Expert Group member. He is the co-creator of the popular OmniFaces library for JSF that was a 2015 Duke’s Choice Award winner, and is the main creator of a set of tests for the Java EE authentication SPI (JASPIC) that has been used by various Java EE vendors. Arjan holds an MSc degree in Computer Science from the University of Leiden, The Netherlands. Writing about this topic was a natural choice for Arjan; He has already written much about it at his blog and would like to expand that by contributing to a book.1. History2. From Zero To Hello World3. Components4. Form Components5. Validation and Conversion6. Output Components7. Facelets Templating8. Backing Beans9. Exception Handling10. WebSocket Push11. Custom Components12. Search Expressions13. Security14. Localization15. Extensions
R 4 Quick Syntax Reference
This handy reference book detailing the intricacies of R covers version 4.x features, including numerous and significant changes to syntax, strings, reference counting, grid units, and more.Starting with the basic structure of R, the book takes you on a journey through the terminology used in R and the syntax required to make R work. You will find looking up the correct form for an expression quick and easy. Some of the new material includes information on RStudio, S4 syntax, working with character strings, and an example using the Twitter API.With a copy of the R 4 Quick Syntax Reference in hand, you will find that you are able to use the multitude of functions available in R and are even able to write your own functions to explore and analyze data.WHAT YOU WILL LEARN* Discover the modes and classes of R objects and how to use them* Use both packaged and user-created functions in R* Import/export data and create new data objects in R* Create descriptive functions and manipulate objects in R* Take advantage of flow control and conditional statements* Work with packages such as base, stats, and graphicsWHO THIS BOOK IS FORThose with programming experience, either new to R, or those with at least some exposure to R but who are new to the latest version. Margot Tollefson is a self-employed consulting statistician residing in the tiny town of Stratford in the corn and soybean fields of north-central Iowa. She started using the S-Plus language in the early 1990s and was happy to switch to R about ten years ago. Margot enjoys writing her own functions in R - to do plots and simulations, as well as to implement custom modeling and use published statistical methods. She earned her graduate degrees in statistics from Iowa State University in Ames, Iowa.Part 1: R Basics1. Downloading R and Setting Up a File System2. The R Prompt3. Assignments and OperatorsPart 2: Kinds of Objects4. Modes of Objects5. Classes of ObjectsPart 3: Functions6. Packaged Functions7. User Created Functions8. How to Use a FunctionPart 4: I/O and Manipulating Objects9. Importing/Creating Data10. Exporting from R11. Descriptive Functions and Manipulating ObjectsPart 5: Flow control12. Flow Control13. Examples of Flow Control14. The Functions ifelse() and switch()Part 6: Some Common Functions, Packages and Techniques15. Some Common Functions16. The Packages base, stats and graphics17. The Tricks of the Trade
Modern Parallel Programming with C++ and Assembly Language
Learn the fundamentals of x86 Single instruction multiple data (SIMD) programming using C++ intrinsic functions and x86-64 assembly language. This book emphasizes x86 SIMD programming topics and technologies that are relevant to modern software development in applications which can exploit data level parallelism, important for the processing of big data, large batches of data and related important in data science and much more.Modern Parallel Programming with C++ and Assembly Language is an instructional text that explains x86 SIMD programming using both C++ and assembly language. The book’s content and organization are designed to help you quickly understand and exploit the SIMD capabilities of x86 processors. It also contains an abundance of source code that is structured to accelerate learning and comprehension of essential SIMD programming concepts and algorithms.After reading this book, you will be able to code performance-optimized AVX, AVX2, and AVX-512 algorithms using either C++ intrinsic functions or x86-64 assembly language.WHAT YOU WILL LEARN* Understand the essential details about x86 SIMD architectures and instruction sets including AVX, AVX2, and AVX-512.* Master x86 SIMD data types, arithmetic instructions, and data management operations using both integer and floating-point operands.* Code performance-enhancing functions and algorithms that fully exploit the SIMD capabilities of a modern x86 processor.* Employ C++ intrinsic functions and x86-64 assembly language code to carry out arithmetic calculations using common programming constructs including arrays, matrices, and user-defined data structures.* Harness the x86 SIMD instruction sets to significantly accelerate the performance of computationally intense algorithms in applications such as machine learning, image processing, computer graphics, statistics, and matrix arithmetic.* Apply leading-edge coding strategies and techniques to optimally exploit the x86 SIMD instruction sets for maximum possible performance. WHO THIS BOOK IS FORIntermediate to advanced programmers/developers in general. Readers of this book should have previous programming experience with modern C++ (i.e., ANSI C++11 or later) and Assembly. Some familiarity with Microsoft’s Visual Studio or the GNU toolchain will be helpful. The target audience for Modern X86 SIMD Programming are experienced software developers, programmers and maybe some hobbyists.DANIEL KUSSWURM has over 35 years of professional experience as a software developer, computer scientist, and author. During his career, he has developed innovative software for medical devices, scientific instruments, and image processing applications. On many of these projects, he successfully employed C++ intrinsic functions, x86 assembly language, and SIMD programming techniques to significantly improve the performance of computationally intense algorithms or solve unique programming challenges. His educational background includes a BS in electrical engineering technology from Northern Illinois University along with an MS and PhD in computer science from DePaul University. Daniel Kusswurm is also the author of Modern X86 Assembly Language Programming (ISBN: 978-1484200650), Modern X86 Assembly Language Programming, Second Edition (ISBN: 978-1484240625), and Modern Arm Assembly Language Programming (ISBN: 978 1484262665), all published by Apress.Modern X86 SIMD Programming – Outline Page 1 of 7D. Kusswurm – F:\ModX86SIMD\Outline\ModernX86SIMD_Outline (v1).docxIntroductionThe Introduction presents an overview of the book and includes concise descriptions of each chapter. It also summaries thehardware and software tools required to use the book’s source code.OverviewTarget AudienceChapter DescriptionsSource CodeAdditional ResourcesChapter 1 – SIMD FundamentalsChapter 1 discusses SIMD fundamentals including data types, basic arithmetic, and common data manipulation operations.Understanding of this material is necessary for the reader to successfully comprehend the book’s subsequent chapters.What is SIMD?Simple C++ example (Ch01_01)Brief History of x86 SIMD Instruction Set ExtensionsMMXSSE – SSE4.2AVX, AVX2, and AVX-512SIMD Data TypesFundamental types128b, 256b, 512bInteger typesPacked i8, i16, i32, i64 (signed and unsigned)Floating-point typesPacked f16/b16, f32 and f64Little-endian storageSIMD ArithmeticIntegerAddition and subtractionWraparound vs. saturatedMultiplicationBitwise logicalFloating-pointAddition, subtraction, multiplication, division, sqrtHorizontal addition and subtractionFused multiply-accumulate (FMA)SIMD OperationsIntegerMin & maxComparesShuffles, permutations, and blends Size promotions and reductionsFloating-pointMin & maxComparesShuffles, permutations, and blendsSize promotions and reductionsModern X86 SIMD Programming – Outline Page 2 of 7D. Kusswurm – F:\ModX86SIMD\Outline\ModernX86SIMD_Outline (v1).docxMasked movesConditional execution and merging (AVX-512)SIMD Programming OverviewC++ compiler optionsC++ SIMD intrinsic functionsAssembly language functionsTesting for AVX, AVX2, and AVX-512Chapter 2 – AVX C++ Programming - Part 1Chapter 2 teaches AVX integer arithmetic and other operations using C++ intrinsic functions. It also discusses how to code afew simple image processing algorithms using C++ intrinsic functions and AVX instructions.Basic Integer ArithmeticAddition (Ch02_01)Subtraction (Ch02_02)Multiplication (Ch02_03)Common Integer OperationsBitwise logical operations (Ch02_04)Arithmetic and logical shifts (Ch02_05)Image Processing AlgorithmsPixel minimum and maximum (Ch02_06) Pixel mean (Ch02_07)Chapter 3 – AVX C++ Programming - Part 2Chapter 3 is similar to the previous chapter but emphasizes floating-point instead of integer values. This chapter alsoexplains how to employ C++ intrinsic functions to perform SIMD arithmetic operations using floating-point arrays andmatrices.Basic Floating-Point Arithmetic Addition, subtraction, etc. (Ch03_01)Compares (Ch03_02)Conversions (Ch03_03)Floating-Point ArraysArray mean and standard deviation (Ch03_04, Ch03_05)Array square roots and compares (Ch03_06, Ch03_07)Floating-Point MatricesMatrix column means (Ch03_08, Ch03_09)Chapter 4 – AVX2 C++ Programming - Part 1Chapter 4 describes AVX2 integer programming using C++ intrinsic functions. This chapter also highlights the coding of moresophisticated image processing functions using the AVX2 instruction set.Basic Integer ArithmeticAddition and subtraction (Ch04_01) Pack and unpack operations (Ch04_02)Size promotions (Ch04_03)Image Processing AlgorithmsPixel clipping (Ch04_04)RGB to grayscale (Ch04_05)Modern X86 SIMD Programming – Outline Page 3 of 7D. Kusswurm – F:\ModX86SIMD\Outline\ModernX86SIMD_Outline (v1).docxThresholding (Ch04_06)Pixel conversions (Ch04_07)Chapter 5 – AVX2 C++ Programming - Part 2Chapter 5 explains how to accelerate the performance of commonly used floating-point algorithms using C++ intrinsicfunctions and the AVX2 instruction set. The source code examples in this chapter also demonstrate use of FMA (fusedmultiply-add) arithmetic.Floating-Point ArraysLeast squares with FMA (Ch05_01)Floating-Point MatricesMatrix multiplication (Ch05_02, Ch05_03)Matrix (4x4) multiplication (Ch05_04, Ch05_05)Matrix (4x4) vector multiplication (Ch05_06)Matrix inversion (Ch05_07, Ch05_08)Chapter 6 – AVX2 C++ Programming - Part 3Chapter 6 is a continuation of the previous chapter. It focuses on more advanced algorithms and SIMD programmingtechniques.Signal ProcessingBrief overview of convolution arithmetic1D ConvolutionsVariable and fixed width kernels (Ch06_01, Ch06_02)2D ConvolutionsNon-separable kernel (Ch06_03)Separable kernel (Ch06_04)Chapter 7 – AVX-512 C++ Programming - Part 1Chapter 7 explains AVX-512 integer arithmetic and other operations using C++ intrinsic functions. It also discusses how tocode a few basic image processing algorithms using the AVX-512 instruction set.Integer ArithmeticAddition and subtraction (Ch07_01)Masked arithmetic (Ch07_02)Image ProcessingRGB to grayscale (Ch07_03)Image thresholding (Ch07_04)Image statistics (Ch07_05)Chapter 8 – AVX-512 C++ Programming - Part 2Chapter 8 describes how to code common and advanced floating-point algorithms using C++ intrinsic functions and the AVX512 instruction set.Floating-Point ArithmeticAddition, subtraction, etc. (Ch08_01)Masked operations (Ch08_02)Floating-Point ArraysArray mean and standard deviation (Ch08_03)Modern X86 SIMD Programming – Outline Page 4 of 7D. Kusswurm – F:\ModX86SIMD\Outline\ModernX86SIMD_Outline (v1).docxFloating-Point MatricesCovariance matrix (Ch08_04)Matrix multiplication (Ch08_05, Ch08_06)Matrix (4x4) vector multiplication (Ch08_07)Signal Processing1D convolution using variable and fixed width kernels (Ch08_08)2D convolutions using separable kernel (Ch08_09)Chapter 9 – Supplemental C++ SIMD ProgrammingChapter 9 examines supplemental x86 SIMD programming topics including instruction set detection, how to use SIMD mathlibrary functions, and SIMD operations using text strings.Instruction set detection (Ch09_01)SIMD Math Library FunctionsRectangular to polar coordinate conversions (Ch09_02)Body surface area calculations (Ch09_03)SIMD String OperationsString length (Ch09_04)Chapter 10 – X86 Processor ArchitectureChapter 10 explains x86 processor architecture including data types, register sets, memory addressing modes, and conditioncodes. Knowledge of this material is necessary for the reader to successfully understand the subsequent x86 assemblylanguage programming chapters.Data typesFundamental data typesNumerical data types SIMD data typesStringsInternal architectureGeneral-purpose registersRFLAGS registerMXCSR registerScalar FP and SIMD registersMemory addressingCondition codesChapter 11 – Core Assembly Language Programming – Part 1Chapter 11 teaches fundamental x86-64 assembly language programming and basic instruction use. Understanding of thismaterial is required to comprehend the source code examples in subsequent chapters.Integer ArithmeticAddition and subtraction (Ch11_01)Multiplication (Ch11_02)Division (Ch11_03)Mixed integer types and stack arguments (Ch11_04)Integer OperationsMemory addressing modes (Ch11_05)Simple for-loops (Ch11_06)Modern X86 SIMD Programming – Outline Page 5 of 7D. Kusswurm – F:\ModX86SIMD\Outline\ModernX86SIMD_Outline (v1).docxCompares (Ch11_07)Text StringsString instructions (Ch11_08)Chapter 12 – Core Assembly Language Programming – Part 2Chapter 12 is a continuation of the previous chapter. Topics discussed include scalar floating-point arithmetic, floating-pointarrays, and function calling conventions.Scalar Floating-Point ArithmeticSingle-precision arithmetic (Ch12_01)Double-precision arithmetic (Ch12_02)Compares (Ch12_03)Conversions (Ch12_04)Scalar Floating-Point Arrays Mean, SD (Ch12_05)Function Calling ConventionStack frames (Ch12_06)Using non-volatile general-purpose registers (Ch12_07)Using non-volatile SIMD registers (Ch12_08)Macros for function prologues and epilogues (Ch12_09)Chapter 13 – AVX Assembly Language Programming – Part 1Chapter 13 explains AVX integer arithmetic and other operations using x86-64 assembly language. It also describes how tocode a few simple image processing algorithms using assembly language.Integer ArithmeticAddition and subtraction (Ch13_01)Multiplication (Ch13_02)Common Integer Operations Bitwise logical operations (Ch13_03)Arithmetic and logical shifts (Ch13_04)Image Processing AlgorithmsPixel minimum and maximum (Ch13_05)Pixel mean (Ch13_06)Chapter 14 – AVX Assembly Language Programming – Part 2Chapter 14 is similar to the previous chapter but uses floating-point instead of integer values. This chapter also illustrateshow to employ x86-64 assembly language to perform SIMD arithmetic operations using arrays and matrices.Basic Floating-Point ArithmeticAddition and subtraction, etc. (Ch14_01)Compares and size conversions (Ch14_02)Floating-Point ArraysArray mean and standard deviation (Ch14_03)Array square roots and compares (Ch14_04)Floating-Point MatricesMatrix column means (Ch14_05)Modern X86 SIMD Programming – Outline Page 6 of 7D. Kusswurm – F:\ModX86SIMD\Outline\ModernX86SIMD_Outline (v1).docxChapter 15 – AVX2 Assembly Language Programming – Part 1Chapter 15 describes AVX2 integer programming using x86-64 assembly language. This chapter also highlights the coding ofmore sophisticated image processing functions using the AVX2 instruction set.Integer ArithmeticAddition and subtraction (Ch15_01)Image ProcessingPixel clipping (Ch15_02)RGB to grayscale (Ch15_03)Thresholding (Ch15_04)Pixel conversions (Ch15_05)Chapter 16 – AVX2 Assembly Language Programming – Part 2Chapter 16 explains how to enhance the performance of frequently used floating-point algorithms using x86-64 assemblylanguage and the AVX2 instruction set.Floating-Point ArraysLeast squares with FMA (Ch16_01)Floating-Point MatricesMatrix multiplication (Ch16_02)Matrix (4x4) multiplication (Ch16_03)Matrix (4x4) vector multiplication (Ch16_04)Signal Processing1D convolutions using fixed and variable width kernels (Ch16_05)Chapter 17 – AVX-512 Assembly Language Programming – Part 1Chapter 17 highlights AVX-512 integer arithmetic and other operations using x86-64 assembly language. It also discusseshow to code a few simple image processing algorithms using the AVX-512 instruction set.Integer ArithmeticAddition and subtraction (Ch17_01)Compares, merge masking, and zero-masking (Ch17_02)Image ProcessingPixel clipping (Ch17_03)Image statistics (Ch17_04)Chapter 18 – AVX-512 Assembly Language Programming – Part 2Chapter 18 explains how to code common and advanced floating-point algorithms using x86-64 assembly language and theand the AVX-512 instruction set.Floating-Point ArraysCorrelation coefficient (Ch18_01)Merge and zero masking (Ch18_02)Embedded rounding and broadcasts (Ch18_03)Floating-Point MatricesMatrix (4x4) vector multiplication (Ch18_04)Signal Processing 1D convolutions using fixed and variable width kernels (Ch18_05)Modern X86 SIMD Programming – Outline Page 7 of 7D. Kusswurm – F:\ModX86SIMD\Outline\ModernX86SIMD_Outline (v1).docxAppendix A – Source Code and Development ToolsAppendix A describes how to download, install, and execute the source code. It also includes some brief usage notesregarding Visual Studio and the GNU C++ compiler.Source Code Download InformationSoftware Development ToolsMicrosoft Visual StudioGNU C++ compilerAppendix B – References and Additional ResourcesAppendix B contains a list of references that were consulted during the writing of this book. It also lists supplementalresources that the reader can consult for additional x86 SIMD programming information.X86 SIMD Programming ReferencesAlgorithm ReferencesC++ ReferencesAdditional Resources
Python for MATLAB Development
MATLAB can run Python code!Python for MATLAB Development shows you how to enhance MATLAB with Python solutions to a vast array of computational problems in science, engineering, optimization, statistics, finance, and simulation. It is three books in one:* A thorough Python tutorial that leverages your existing MATLAB knowledge with a comprehensive collection of MATLAB/Python equivalent expressions* A reference guide to setting up and managing a Python environment that integrates cleanly with MATLAB* A collection of recipes that demonstrate Python solutions invoked directly from MATLABThis book shows how to call Python functions to enhance MATLAB's capabilities. Specifically, you'll see how Python helps MATLAB:* Run faster with numba* Distribute work to a compute cluster with dask* Find symbolic solutions to integrals, derivatives, and series summations with SymPy* Overlay data on maps with Cartopy* Solve mixed-integer linear programming problems with PuLP* Interact with Redis via pyredis, PostgreSQL via psycopg2, and MongoDB via pymongo* Read and write file formats that are not natively understood by MATLAB, such as SQLite, YAML, and iniWHO THIS BOOK IS FORMATLAB developers who are new to Python and other developers with some prior experience with MATLAB, R, IDL, or Mathematica.ALBERT DANIAL is an aerospace engineer with 30 years of experience, currently working for Northrop Grumman near Los Angeles. Before Northrop Grumman, he was a member of the NASTRAN Numerical Methods team at MSC Software and a systems analyst at SPARTA. He has a Bachelor of Aerospace Engineering degree from the Georgia Institute of Technology, and Masters and Ph.D. degrees in Aeronautics and Astronautics from Purdue University. He is the author of cloc, the open source code counter.Al has used MATLAB since 1990 and Python since 2006 for algorithm prototyping, earth science data processing, spacecraft mission planning, optimization, visualization, and countless utilities that simplify daily engineering work. Chapter 1: IntroductionGoal: Describe the book’s goals, what to expect, what benefit to gain.• Learn Python through MATLAB Equivalents• Is Python really free?• What About Toolboxes?• I already know Python. How do I call Python functions in MATLAB?• What you won’t find in this book• Beyond MATLABPart I – Learning Python through MATLAB comparisonsChapter 2: InstallationGoal: Create a working Python installation on the computer with MATLAB• Downloads• Post-Install Checkout• ipython, IDE’s• Python and MATLAB Versions Used in This BookChapter 3: Language BasicsGoal: Learn the basic mechanics of Python• Assignment• Printing• Indentation• Indexing• `for` Loops• `while` Loops• `if` Statements• Functions• Comments• Line Continuation• Exceptions• Modules and PackagesChapter 4: Data ContainersGoal: Learn about lists, dictionaries, etc, and how these compare to MATLAB matrices and cell arrays• NumPy Arrays• Strings• Python Lists and MATLAB Cell Arrays• Python Tuples • Python Sets and MATLAB Set Operations• Python Dictionaries and MATLAB Maps• Structured Data• Tables• Caveat: ```=`'' copies a reference for non-scalars!Chapter 5: Date and TimeGoal: Learn about measuring, storing, and converting temporal values.• Time• Dates• Timezones• Time Conversions to and from `datetime` ObjectsChapter 6: Input and OutputGoal: Learn about reading and writing data, with emphasis on numeric data and scientific file formats like HDF and NetCDF.• Reading and Writing Text Files• Reading and Writing Binary Files• Reading and Writing Pickle Files• Reading and Writing `.mat` files• Command Line Input • Interactive Input• Receiving and Sending over a Network• Interacting with DatabasesChapter 7: Interacting with the File SystemGoal: Show how Python manages file system operations.• Reading Directory Contents• Finding Files• Deleting Files• Creating Directories• Deleting Directories• Walking Directory TreesChapter 8: Interacting with the Operating System and External ExecutablesGoal: Show how to make system calls in Python and how these differ from MATLAB.• Reading, setting environment variables• Calling External Executables• Inspecting the Process Table and Process ResourcesPart II – MATLAB with PythonChapter 9: MATLAB/Python IntegrationGoal: Show how to make system calls in Python and how these differ from MATLAB.• MATLAB’s `py` Module• System calls and File I/O• TCP/IP ExchangeChapter 10: Object Oriented ProgrammingGoal: Demonstrate Python’s OO semantics compared to MATLAB• Classes• Custom Exceptions• Performance ImplicationsChapter 11: NumPy and SciPyGoal: Introduce Python’s numeric and scientific computing capability. This is by far the largest chapter in the book.• NumPy Arrays• Linear Algebra• Sparse Matrices• Interpolation • Curve Fitting• Statistics• Finding Roots• Optimization • Differential Equations• Symbolic Mathematics• Unit SystemsChapter 12: PlottingGoal: Demonstrate how publication-quality plots are produced in Python alongside MATLAB equivalents• Point and Line Plots• Area Plots• Animations• Plotting on Maps• 3D Plots• Making plots in batch modeChapter 13: Tables and DataframesGoal: Show Pandas dataframes in comparison to MATLAB tables (and how the former pre-dates the latter by five years)• Loading tables from files• Table summaries• Cleaning data• Creating tables programmatically• Sorting rows• Table subsets• Iterating over rows• Pivot tables• Adding columns• Deleting columns• Joins across tablesChapter 14: High Performance ComputingGoal: Demonstrate techniques for profiling Python code and making computationally intensive Python code run faster. Significant performance advantages over MATLAB are shown.• Paths to faster Python code• Reference Problems• Reference Hardware and OS• Baseline performance• Profiling Python Code• Vectorization• Cython• Pythran• Numba• Linking to C, C++, Fortran• Distributed memory parallel processingChapter 15: `py` Module ExamplesGoal: A collection of examples that show how Python enables the core MATLAB product to perform tasks that would either require a Toolbox or less-vetted code from the MathWorks’ user contributed FileExchange.• Read a YAML File• Write a YAML File• Compute Laplace Transforms• Interact with Redis• Units• Propagate a satellite’s orbit• Controls• Plotting on mapsChapter 16: Language WartsGoal: Identify MATLAB and Python language ‘features’ that often cause beginners grief.• Dangerous language features• MATLAB• Python• Common Errors
Java For Dummies
LEARN TO WRITE PRACTICAL, REUSABLE CODE WITH THE STRAIGHT FORWARD TUTORIALS AND TIPS IN THE NEWEST EDITION OF THIS FOR DUMMIES BESTSELLERDo you speak Java? No, we’re not talking about your morning cup ‘o joe. We mean the world’s most popular programming language that runs on almost any computer!If you’re looking to get started—or up your game—with Java, then Java For Dummies is the guide you need.In this book, you’ll:* Take control of your program flow* Program with classes, objects, and methods* Use Java's functional programming features* Explore Java 17, the latest long-term support releaseThis up-to-date handbook covers the latest developments in Java, including the new ‘switch’ statement syntax. So, if you’re ready to dive into one of the most practical (and coolest!) programming languages around, it’s time you picked upJava For Dummies.DR. BARRY BURD holds an M.S. in Computer Science from Rutgers University and a Ph.D. in Mathematics from the University of Illinois. Barry is also the author of Beginning Programming with Java For Dummies, Java for Android For Dummies, and Flutter For Dummies.INTRODUCTION 1About This Book 1Foolish Assumptions 2Icons Used in This Book 3Beyond the Book 4Where to Go from Here 4PART 1: GETTING STARTED WITH JAVA 5CHAPTER 1: ALL ABOUT JAVA 7What You Can Do with Java 8Why You Should Use Java 9Gaining Perspective: Where Java Fits In 10Object-Oriented Programming (OOP) 12Object-oriented languages 13Objects and their classes 15What’s so great about an object-oriented language? 15Objects and classes are everywhere 18What’s Next? 19CHAPTER 2: ALL ABOUT SOFTWARE 21Get Ready for Java 21The Inside Scoop 23What is a compiler? 24What is a Java virtual machine? 27Developing Software 31Spoiler Alert! 32CHAPTER 3: USING THE BASIC BUILDING BLOCKS 33Speaking the Java Language 33The grammar and the common names 34The words in a Java program 35Checking Out Java Code for the First Time 37Understanding a Simple Java Program 38The Java class 38The Java method 40The main method in a program 41How you finally tell the computer to do something 43Brace yourself 45And Now, a Few Comments 49Adding comments to your code 49What’s Barry’s excuse? 53Using comments to experiment with your code 53PART 2: WRITING YOUR OWN JAVA PROGRAMS 55CHAPTER 4: MAKING THE MOST OF VARIABLES AND THEIR VALUES 57Varying a Variable 58Assignment statements 60The types of values that variables may have 61How to hold the line 64Numbers without decimal points 65Combining declarations and initializing variables 67Experimenting with JShell 69What Happened to All the Cool Visual Effects? 72The Atoms: Java’s Primitive Types 73The char type 73The boolean type 76The Molecules and Compounds: Reference Types 78An Import Declaration 82Creating New Values by Applying Operators 84Initialize once, assign often 87The increment and decrement operators 89Assignment operators 93CHAPTER 5: CONTROLLING PROGRAM FLOW WITH DECISION-MAKING STATEMENTS 97Making Decisions (Java if Statements) 98Guess the number 98She controlled keystrokes from the keyboard 99Creating randomness 102The if statement 103Equal, equal 104Brace yourself 105Your intent to indent 105Elseless in Helsinki 106Using Blocks in JShell 108Forming Conditions with Comparisons and Logical Operators 109Comparing numbers; comparing characters 109Comparing objects 110Look! 113Java’s logical operators 115Vive les nuls! 118(Conditions in parentheses) 119The Nesting Habits of if Statements 121Choosing among Many Alternatives 124Java’s glorious switch statement 124A switch in time saves 14 127Your grandparents’ switch statement 130Free fall 131CHAPTER 6: CONTROLLING PROGRAM FLOW WITH LOOPS 135Repeating Instructions Over and Over Again (Java while Statements) 136Count On Me 139The anatomy of a for statement 141The world premiere of “Al’s All Wet” 142You Can Always Get What You Want 145The root of the matter 148Reading a single character 149File handling in Java 150Block on the while side 151PART 3: WORKING WITH THE BIG PICTURE: OBJECT-ORIENTED PROGRAMMING 155CHAPTER 7: THE INSIDE SCOOP 157Defining a Class (What It Means to Be an Account) 158Declaring variables and creating objects 163Initializing a variable 166Using an object’s fields 167One program; several classes 167Declaring a public class 167Defining a Method within a Class (Displaying an Account) 169An account that displays itself 170The display method’s header 172Sending Values to and from Methods (Calculating Interest) 173Passing a value to a method 176Returning a value from the getInterest method 178Giving Your Numbers a Makeover 180Hide-and-Seek 185Good programming 185Public lives and private dreams: Making a field inaccessible 188Enforcing rules with accessor methods 190Barry’s Own GUI Class 190CHAPTER 8: SAVING TIME AND MONEY: REUSING EXISTING CODE 199What It Means to Be an Employee 200The last word on employees 200Putting your class to good use 202Cutting a check 206Working with Disk Files (a Brief Detour) 207Storing data in a file 207Repeat after me 208Reading from a file 209Who moved my file? 212You moved your file! 212Reading a line at a time 213Clean up after yourself 215Defining Subclasses (What It Means to Be a Full-Time or Part-Time Employee) 216Creating a subclass 218Creating subclasses is habit-forming 220Using Subclasses 221Making types match 223The second half of the story 224Changing the Payments for Only Some of the Employees 225A Java annotation 227Using methods from classes and subclasses 228CHAPTER 9: CONSTRUCTING NEW OBJECTS 233Defining Constructors (What It Means to Be a Temperature) 234What is a temperature? 235What is a temperature scale? (Java’s enum type) 235Okay, so then what is a temperature? 236What you can do with a temperature 238Constructing a temperature; a slow-motion replay 240Some things never change 243Doing Something about the Weather 246Building better temperatures 246Constructors for subclasses 248Using all this stuff 249The default constructor 250A Constructor That Does More 254Classes and methods from the Java API 256Live dangerously 257PART 4: SMART JAVA TECHNIQUES 259CHAPTER 10: PUTTING VARIABLES AND METHODS WHERE THEY BELONG 261Defining a Class (What It Means to Be a Baseball Player) 262Another way to beautify your numbers 263Using the Player class 264One class; nine objects 266Don’t get all GUI on me 266Some facts about potatoes 268Making Static (Finding the Team Average) 270Why is there so much static? 272Meet the static initializer 272Displaying the overall team average 273The static keyword is yesterday’s news 276Could cause static; handle with care 276Experiments with Variables 279Putting a variable in its place 280Telling a variable where to go 283Passing Parameters 287Pass by value 288Returning a result 290Pass by reference 290Returning an object from a method 292Epilogue 294CHAPTER 11: USING ARRAYS TO JUGGLE VALUES 295Getting Your Ducks All in a Row 295Creating an array in two easy steps 298How to book hotel guests 299Tab stops and other special things 301Make life easy for yourself 302Stepping through an array with the enhanced for loop 304Do you have a room? 306Writing to a file 308When to close a file 309Arrays of Objects 311Using the Room class 313Yet another way to beautify your numbers 316The conditional operator 317How to Argue with Your Code 318Settling the argument 319Checking for the right number of program arguments 321CHAPTER 12: USING COLLECTIONS AND STREAMS (WHEN ARRAYS AREN’T GOOD ENOUGH) 323Arrays Have Limitations 324Collection Classes to the Rescue 325Using an ArrayList 325Using generics 328Wrap it up 331Are we done yet? 333Once and again 333So many collection classes! 335Functional Programming 336Problem-solving the old-fashioned way 337Lambda expressions 339A black sheep among the lambdas 341A taxonomy of lambda expressions 342The interpretation of streams 342Why bother? 348Method references 351CHAPTER 13: LOOKING GOOD WHEN THINGS TAKE UNEXPECTED TURNS 355Garbage In 356The parameter in a catch clause 360Do it yourself 362Who will catch the exception? 364Catching two or more exceptions at a time 371The Buck Stops Here, Except When It Doesn’t 372Catch it soon 374Catch it later 375Checked or unchecked? 377Try, Try Again! 380CHAPTER 14: SHARING NAMES AMONG THE PARTS OF A JAVA PROGRAM 385Access Modifiers 386Classes and Their Members 386Public and Private Access for Members 387Drawing on a frame 390Putting a package in its place 392Making a frame 394Default Access for Members 396Switching to Default access 398Accessing default members within a package 400Protected Access for Members 402A class in one package and a subclass in another 402Two classes in the same package 404Access Modifiers for Java Classes 408Public classes 408Nonpublic classes 409From Classes Come Modules 410CHAPTER 15: FANCY REFERENCE TYPES 411Java’s Types 411The Java Interface 412Declaring two interfaces 413Implementing interfaces 415Putting the pieces together 417Abstract Classes 420Caring for your pet 423Using all your classes 425Relax! You’re Not Seeing Double! 427CHAPTER 16: JAVA’S JUGGLING ACT 431Juggling Two or More Calls 432Events and event handling 435Follow the thread 436Don’t miss this 437Inside the actionPerformed method 439Some Events Aren’t Button Clicks 440The Inner Sanctum 446CHAPTER 17: USING JAVA DATABASE CONNECTIVITY 451Creating a Database and a Table 452Seeing what happens when you run the code 453Using SQL commands 454Connecting and disconnecting 455Putting Data in the Table 456Retrieving Data 457Destroying Data 459One Step Beyond 461PART 5: THE PART OF TENS 463CHAPTER 18: TEN PACKS OF JAVA WEBSITES 465This Book’s Website 465For Business Issues Related to This Book 465Download the Java Development Kit 466Your Grandparents’ Java Download Site 466The Horse’s Mouth 466Join Java User Groups 466Find the Latest News about Java 466Find News, Reviews, and Sample Code 466Got a Technical Question about Anything? 467Become Involved in the Future of Java 467CHAPTER 19: TEN BITS OF ADVICE FOR NEW SOFTWARE DEVELOPERS 469How Long Does It Take to Learn Java? 470Which of Your Books Should I Read? 470Are Books Other than Yours Good for Learning Java and Android Development? 471Which Computer Programming Language(s) Should I Learn? 471Which Skills Other than Computer Coding Should I Learn? 471How Should I Continue My Learning as a Software Developer? 472How Else Should I Continue My Learning as a Developer? 472How Can I Land a Job Developing Software? 473I Still Don’t Know What to Do with My Life 473If I Have Other Questions, How Can I Contact You? 474Index 475
Python 3 für Studium und Ausbildung
Programmierkenntnisse sind heute eine Kompetenz, die nicht nur in IT-nahen Berufen vorausgesetzt wird. Dieses Buch richtet sich besonders an alle, die Python in Studium und Ausbildung lernen und keine Vorkenntnisse in der Programmierung haben. Die Ausrichtung des Studiengangs spielt dabei keine Rolle. Alle Themen werden fachunabhängig erläutert und die Übungen und praktischen Beispiele decken viele unterschiedliche Anwendungsbereiche ab, so dass Sie auf die verschiedensten Aufgaben optimal vorbereitet sind. Sie werden Schritt für Schritt in die Programmiertechniken eingeführt: von den Grundlagen (Datentypen, Kontrollstrukturen, Funktionen) über die Entwicklung komplexer Anwendungen mit grafischer Benutzungsoberfläche bis hin zur Anbindung an SQL-Datenbanken, Datenvisualisierung und wissenschaftlichem Rechnen mit Arrays (NumPy). Dabei lernen Sie auch, gut lesbare Programmtexte und sauberen Code zu schreiben, und erfahren, wie Sie Fehler finden und von Anfang an vermeiden können. Zahlreiche praktische Programmierübungen helfen Ihnen, Ihr Wissen zu festigen und sich auf Prüfungssituationen vorzubereiten. Die Lösungen zu allen Übungen inklusive Programmcode finden Sie auf der Verlagsseite zum kostenlosen Download.Aus dem Inhalt: Alle Grundlagen einfach erklärtObjektorientierte ProgrammierungMit Modulen arbeiten und eigene Module erstellenVerarbeiten von Texten und BildernGrafische Benutzungsoberflächen mit tkinterSQL-Datenbanken mit sqlite3Wissenschaftliches Rechnen mit NumPyDatenvisualisierung mit MatplotlibNutzung von CoLab und PythonAnywhereWebprogrammierung mit CGI und WSGIAgile Softwareentwicklung Über den Autor: Michael Weigend hat an der Universität Potsdam in Informatik promoviert. Er war für mehr als 30 Jahre als Lehrer tätig und hat 20 Jahre lang an der FernUniversität Hagen Seminare zur Didaktik der Informatik gegeben. An der Universität Münster hält er im Rahmen eines Lehrauftrags Vorlesungen zur Python-Programmierung. Michael Weigend engagiert sich in mehreren nationalen und internationalen Communities für den Computer-Einsatz in der Bildung, darunter Constructionism, International Federation for Information Processing (TC 3 Computers in Education) , Bebras – International Contest on Informatics and Computational Thinking. Er hat über 60 wissenschaftliche Artikel veröffentlicht und mehrere Bücher zu den Themen Programmierung, Web Development und visuelle Modellierung geschrieben.
Let's code Scratch! (2. Auflage)
Werde ein echter Programmierer und schreibe deine eigenen Spiele und andere Programme: Scratch ist eine Programmiersprache extra für Kinder und Jugendliche, die leicht zu erlernen ist. Du brauchst kein Vorwissen und lernst in tollen Projekten schrittweise alle Funktionen kennen. Setze dein Wissen ein, um Bälle hüpfen, Katzen tanzen oder Luftballons zerplatzen zu lassen. Deiner Kreativität sind keine Grenzen gesetzt. Ganz nach dem Motto von Scratch: Ausdenken, entwickeln, teilen.Aus dem Inhalt:Scratch installierenScratch im Browser nutzenDie wichtigsten BefehleDein erstes Spiel: Der springende BallDas magische LabyrinthWürfel-, Zahlen- und RatespieleSchreibe dein eigenes Jump'n'RunEigene Spiele mit anderen teilenAlle Projekte auch zum Download Leseprobe (PDF)Autor:Hauke Fehr programmiert seit über 30 Jahren Apps für verschiedene Einsatzzwecke. Die Wissensvermittlung liegt ihm dabei besonders am Herzen.
Data Science in der Praxis
Der ideale Einstieg in Data Science für Praktiker! Ob mit oder ohne Mathematikkenntnisse – Sie bekommen hier den Rundumblick, den Sie für Ihre Projekte brauchen. So heben Sie den Schatz, den Daten darstellen können, wenn man sie richtig befragt. Sie lernen die einschlägigen Analysemethoden kennen, bekommen eine Einführung in die Programmiersprache R und erfahren, wie Sie maschinelles Lernen einsetzen. Und zwar inklusive dazugehöriger Werkzeuge wie Notebooks, die die Data-Science-Programmierung heutzutage so zugänglich machen. Und weil es mit der Technik allein nicht getan ist, geht das Buch auch auf Probleme der Projektdurchführung ein, beleuchtet verschiedene Anwendungsfelder und vergisst auch nicht, ethische Aspekte anzusprechen. Mit vielen Beispielen, Hinweisen für den Fehlerfall, Entscheidungshilfen und weiteren Praxistipps. Aus dem Inhalt: Erste Schritte mit R und RStudioGrundbegriffe der StatistikVorbereitung: Daten reinigen und transformierenk-Means ClusteringLineare und nichtlineare RegressionVorhersagen, Clustering, KlassifizierungTipps und Werkzeuge für alle ProjektphasenIhre Anwendung als REST-API bereitstellenKI und Maschinelles Lernen einsetzenAnomalieerkennung, Warenkorbanalyse und viele weitere AnwendungsfälleMachine Learning: Modelle richtig trainieren Materialien zum Buch ... 13 1. Einleitung ... 15 1.1 ... Warum dieses Buch? ... 15 1.2 ... Das Zeitalter der Daten -- alles nur ein Hype? ... 16 1.3 ... Warum nun Data Science? ... 17 1.4 ... Warum Data Science mit R? ... 19 1.5 ... Für wen ist dieses Buch? ... 20 1.6 ... Kann man Data Science ohne Mathe lernen? ... 20 1.7 ... Wie Sie dieses Buch verwenden können ... 22 1.8 ... Materialien und Kontakt ... 22 1.9 ... Danksagungen ... 22 2. Machine Learning, Data Science und künstliche Intelligenz ... 25 2.1 ... Aus der Geschichte lernen -- alles nur ein Hype? ... 25 2.2 ... Begriffsdefinitionen ... 34 3. Ablauf eines Data-Science-Projekts ... 39 3.1 ... Der allgemeine Ablauf eines Data-Science-Projekts ... 39 3.2 ... Business Understanding: Welches Problem soll gelöst werden? ... 43 3.3 ... Grundsätzliche Ansätze im Machine Learning ... 47 3.4 ... Performancemessung ... 49 3.5 ... Kommunikation mit Stakeholdern ... 57 3.6 ... Aus dem Labor in die Welt: Data-Science-Applikationen in Produktion ... 58 3.7 ... Die verschiedenen Rollen in einem Data-Science-Projekt ... 59 4. Einführung in R ... 67 4.1 ... R: kostenlos, portierbar und interaktiv ... 67 4.2 ... Installation und Konfiguration von R und RStudio ... 74 4.3 ... Erste Schritte mit R ... 89 5. Explorative Datenanalyse ... 111 5.1 ... Daten: Sammlung, Reinigung und Transformation ... 112 5.2 ... Notebooks ... 117 5.3 ... Das Tidyverse ... 123 5.4 ... Datenvisualisierung ... 137 5.5 ... Datenanalyse ... 148 6. Anwendungsfall Prognosen ... 159 6.1 ... Lineare Regression ... 159 6.2 ... Anomalie-Erkennung ... 176 7. Clustering ... 185 7.1 ... Hierarchisches Clustering ... 185 7.2 ... k-Means ... 197 8. Klassifikation ... 207 8.1 ... Anwendungsfälle für eine Klassifikation ... 207 8.2 ... Trainings- und Testdaten erstellen ... 209 8.3 ... Decision Trees ... 217 8.4 ... Support Vector Machines ... 221 8.5 ... Naive Bayes ... 226 8.6 ... XG Boost: Der Newcomer ... 232 8.7 ... Klassifikation von Text ... 238 9. Weitere Anwendungsfälle ... 245 9.1 ... Warenkorbanalyse -- Association Rules ... 245 9.2 ... k-nearest Neighbours ... 254 10. Workflows und Werkzeuge ... 267 10.1 ... Versionierung mit Git ... 267 10.2 ... Mit großen Datenmengen umgehen ... 277 10.3 ... Applikationen via API bereitstellen ... 287 10.4 ... Applikationen erstellen mit Shiny ... 292 11. Ethischer Umgang mit Daten und Algorithmen ... 307 11.1 ... Datenschutz ... 307 11.2 ... Ethik: Gegen Profiling und Diskriminierung ... 317 12. Was kommt nach diesem Buch? ... 325 12.1 ... Projekte, Projekte, Projekte ... 325 12.2 ... Wer hilft Ihnen jetzt weiter? ... 329 12.3 ... RSeek ... 335 Anhang ... 337 A ... Typische Fehlermeldungen und geeignete Lösungen ... 339 B ... Glossar ... 343 C ... Literatur ... 347 Index ... 353
SAP Fiori Elements
Erstellen Sie SAP-Fiori-Apps ganz einfach und ohne JavaScript-Programmierung! Dieses Buch zeigt Ihnen, wie Sie sich den Low-Code-Ansatz von SAP Fiori Elements zunutze machen, um Entwicklungszeiten und -aufwand zu reduzieren. In praktischen Beispielen werden Sie duch die Entwicklung von Übersichts- und Detailseiten, analytischen Anwendungen und Objektseiten geführt. Und wenn doch noch individuelle Anpassungen an Ihren Apps erforderlich sind, finden Sie auch dazu hilfreiche Tipps und Anleitungen. Aus dem Inhalt: Warum SAP Fiori Elements?AnwendungsszenarienEinführung in SAPUI5 und SAP FioriOData-GrundlagenEntwicklungsumgebungenEinsatz im SAP Cloud Application Programming ModelEinsatz im ABAP-RESTful-ProgrammiermodellEntwicklungsbeispiele für alle Floorplans Deployment und ErweiterungInterne und externe Navigation Einleitung ... 13 Teil I Grundlagen ... 17 1. Warum SAP Fiori Elements? ... 19 1.1 ... Historische Entwicklung der Benutzeroberflächen bei SAP ... 20 1.2 ... Anforderungen an Benutzeroberflächen in SAP-on-Premise- und -Cloud-Produkten ... 31 1.3 ... Low-Code-Entwicklung ... 35 1.4 ... Beispielapplikation ... 37 2. Was Sie über SAPUI5 und SAP Fiori wissen sollten ... 39 2.1 ... Kurze Einführung in SAPUI5 ... 39 2.2 ... Standardisierte Entwicklung mit SAP Fiori ... 43 3. OData als Basis für SAP-Fiori-Elements-Applikationen ... 67 3.1 ... Einführung in den OData-Standard ... 68 3.2 ... CRUDQ-Methoden ... 72 3.3 ... Filterung, Sortierung und sonstige Funktionen ... 82 3.4 ... Verwaltung der OData-Services im SAP-System ... 90 3.5 ... OData- und CDS-Annotationen ... 97 4. Programmiermodelle ... 101 4.1 ... Warum braucht es neue Programmiermodelle für die Cloud? ... 102 4.2 ... SAP Cloud Application Programming Model ... 105 4.3 ... ABAP RESTful Application Programming Model ... 116 5. Entwicklungstools ... 123 5.1 ... Cloud-Entwicklungsumgebungen ... 123 5.2 ... Lokale Entwicklungsumgebungen ... 144 Teil II Entwicklung mit Floorplans ... 161 6. Einführung in Floorplans und Anwendungsszenarien ... 163 6.1 ... Verfügbare Floorplans ... 163 6.2 ... Anwendungsfälle für die Floorplans ... 174 6.3 ... Generische Annotationen ... 175 7. Overview Page ... 179 7.1 ... Einführung ... 179 7.2 ... Annotationen für Overview Pages ... 189 7.3 ... CDS View für eine Overview Page ... 190 7.4 ... Entwicklung einer Overview Page im SAP Business Application Studio ... 192 7.5 ... Entwicklung einer Overview Page in der SAP Web IDE ... 212 8. List Report und Worklist ... 217 8.1 ... Einführung ... 217 8.2 ... Annotationen für List Reports und Worklists ... 230 8.3 ... Entwicklung eines List Reports in der SAP Web IDE ... 231 8.4 ... Entwicklung eines List Reports im SAP Business Application Studio ... 243 8.5 ... Entwicklung einer Worklist im SAP Business Application Studio ... 249 9. Analytical List Page ... 257 9.1 ... Einführung ... 258 9.2 ... Annotationen für Analytical List Pages ... 267 9.3 ... CDS View für eine Analytical List Page ... 273 9.4 ... Entwicklung einer Analytical List Page im SAP Business Application Studio ... 276 9.5 ... Entwicklung einer Analytical List Page in der SAP Web IDE ... 287 9.6 ... Weiterentwicklung der Analytical List Page ... 292 10. Object Page ... 295 10.1 ... Einführung ... 295 10.2 ... Annotationen für Object Pages ... 303 10.3 ... CDS View für eine Object Page ... 315 10.4 ... Entwicklung einer Object Page in der SAP Web IDE ... 317 10.5 ... Entwicklung einer Object Page im SAP Business Application Studio ... 325 Teil III Weiterführende Konzepte ... 329 11. Deployment ... 331 11.1 ... Continuous Integration und Continuous Delivery ... 332 11.2 ... Deployment-Optionen ... 334 11.3 ... SAP Fiori Launchpad konfigurieren ... 344 12. Erweiterungen ... 365 12.1 ... Erweiterungsentwicklung mit dem Guided Development ... 366 12.2 ... Overview Page erweitern ... 370 12.3 ... List Report erweitern ... 380 12.4 ... Object Page erweitern ... 386 12.5 ... Analytical List Page erweitern ... 388 12.6 ... Erweiterungsprojekt implementieren ... 395 13. Navigation ... 409 13.1 ... Interne Navigation ... 409 13.2 ... Externe Navigation ... 416 Anhang. Wichtige Annotationen ... 423 Das Autorenteam ... 429 Index ... 431
Introducing Software Verification with Dafny Language
Get introduced to software verification and proving correctness using the Microsoft Research-backed programming language, Dafny. While some other books on this topic are quite mathematically rigorous, this book will use as little mathematical symbols and rigor as possible, and explain every concept using plain English. It's the perfect primer for software programmers and developers with C# and other programming language skills.Writing correct software can be hard, so you'll learn the concept of computation and software verification. Then, apply these concepts and techniques to confidently write bug-free code that is easy to understand. Source code will be available throughout the book and freely available via GitHub.After reading and using this book you'll be able write correct, big free software source code applicable no matter which platform and programming language you use.WHAT YOU WILL LEARN* Discover the Microsoft Research-backed Dafny programming language* Explore Hoare logic, imperative and functional programs* Work with pre- and post-conditions* Use data types, pattern matching, and classes* Dive into verification examples for potential re-use for your own projectsWHO THIS BOOK IS FORSoftware developers and programmers with at least prior, basic programming experience. No specific language needed. It is also for those with very basic mathematical experience (function, variables).BORO SITNIKOVSKI has over ten years of experience working professionally as a software engineer. He started programming with assembly on an Intel x86 at the age of ten. While in high school, he won several prizes in competitive programming, varying from 4th, 3rd, and 1st place. He is an informatics graduate - his bachelor’s thesis was titled “Programming in Haskell using algebraic data structures”, and his master’s thesis was titled “Formal verification of Instruction Sets in Virtual Machines”. He has also published a few papers on software verification. Other research interests of his include programming languages, mathematics, logic, algorithms, and writing correct software. He is a strong believer in the open-source philosophy and contributes to various open-source projects. In his spare time, he enjoys some time off with his family.Introduction: Languages and SystemsChapter 1: Our First ProgramChapter 2: LogicChapter 3: ComputationChapter 4: Mathematical FoundationsChapter 5: ProofsChapter 6: SpecificationsChapter 7: Mathematical InductionChapter 8: Verification ExercisesChapter 9: Implementing a Formal SystemConclusionBibliographyAppendix A: Gödel’s Theorems
Java 17 Recipes
Quickly find solutions to dozens of common programming problems encountered while building Java applications, with recipes presented in the popular problem-solution format. Look up the programming problem that you want to resolve. Read the solution. Apply the solution directly in your own code. Problem solved!Java 17 Recipes is updated to reflect changes in specification and implementation since the Java 9 edition of this book. Java 17 is the next long-term support release (LTS) of the core Java Standard Edition (SE) version 17 which also includes some of the features from previous short term support (STS) releases of Java 16 and previous versions.This new edition covers of some of the newest features, APIs, and more such as pattern matching for switch, Restore Always-Strict-Floating-Point-Semantics, enhanced pseudo-random number generators, the vector API, sealed classes, and enhancements in the use of String. Source code for all recipes is available in a dedicated GitHub repository.This must-have reference belongs in your library.WHAT YOU WILL LEARN* Look up solutions to everyday problems involving Java SE 17 LTS and other recent releases* Develop Java SE applications using the latest in Java SE technology* Incorporate Java major features introduced in versions 17, 16, and 15 into your codeWHO THIS BOOK IS FORProgrammers and developers with some prior Java experience.JOSH JUNEAU has been developing software and enterprise applications since the early days of Java EE. Application and database development have been his focus since the start of his career. He became an Oracle database administrator and adopted the PL/SQL language for performing administrative tasks and developing applications for the Oracle database. In an effort to build more complex solutions, he began to incorporate Java into his PL/SQL applications and later developed standalone and web applications with Java. Josh wrote his early Java web applications utilizing JDBC and servlets or JSP to work with backend databases. Later, he began to incorporate frameworks into his enterprise solutions, such as Java EE and JBoss Seam. Today, he primarily develops enterprise web solutions utilizing Java EE and other technologies. He also includes the use of alternative languages, such as Jython and Groovy, for some of his projects. Over the years, Josh has dabbled in many different programming languages, including alternative languages for the JVM, in particular. In 2006, Josh began devoting time to the Jython Project as editor and publisher of the Jython Monthly newsletter. In late 2008, he began a podcast dedicated to the Jython programming language. Josh was the lead author for The Definitive Guide to Jython, Oracle PL/SQL Recipes, and Java 7 Recipes, and a solo author of Java EE 7 Recipes and Introducing Java EE 7, which were all published by Apress. He works as an application developer and system analyst at Fermi National Accelerator Laboratory, and he also writes technical articles for Oracle and OTN. He was a member of the JSR 372 and JSR 378 expert groups, and is an active member of the Java Community, helping to lead the Chicago Java User Group’s Adopt-a-JSR effort. When not coding or writing, Josh enjoys spending time with his wonderful wife and five children, especially swimming, fishing, playing ball, and watching movies. To hear more from Josh, follow him on Twitter at @javajuneau.LUCIANO MANELLI earned a PhD in computer science from the IT department, University of Bari-Aldo Moro. His PhD focused on grid computing and formal methods, and he published the results in international publications. Luciano obtained several certificates in the IT sector, and, in 2014, began working for the Port Network Authority of the Ionian Sea–Port of Taranto, after working for 13 years for InfoCamere SCpA. He has worked mainly in the design, analysis, and development of large software systems; research and development; testing; and production with roles of increasing responsibility in several areas over the years. Luciano has developed a great capability to make decisions in a technical and business context and is mainly interested in project management and business process management. In his current position, he deals with port community systems and software innovation. Additionally, he has written several IT books and is a contract professor at the Polytechnic of Bari (foundations of computer science), and at the University of Bari-Aldo Moro (programming for web, computer science, and computer lab).1. Getting Started with Java 172. Java 17 Enhancements3. Strings4. Numbers and Dates5. Object-Oriented Java6. Lambda Expressions7. Data Structures and Collections8. Input and Output9. Exceptions and Logging10. Concurrency11. Debugging and Unit Testing12. Unicode, Internationalization, and Currency Codes13. Working with Databases14. JavaFX Fundamentals15. Graphics with JavaFX16. Media with JavaFX17. Java Web Applications18. Nashorn and Scripting19. E-mail20. JSON and XML Processing21. Networking22. Java Modularity
Introducing Blockchain with Java
Create your own crypto currency by implementing blockchain technology using Java. This step-by-step guide will teach you how to create a user interface using Java FX and implement SQLite DB using JDBC Driver for the blockchain.INTRODUCING BLOCKCHAIN WITH JAVA includes numerous exercises and test questions to help you solidify what you have learned as you progress through the book, and provides ideas on expanding the codebase to make it your own. You will have access to a fully-functioning repository with Java code.Upon completing this book, you will have the knowledge necessary to program your own blockchains with Java and you will have a completed project for your portfolio.WHAT YOU WILL LEARN* Know the most important theoretical concepts of the blockchain* Code the blockchain in Java* Create a user interface with JavaFX* Implement SQLite DB using JDBC Driver* Create a P2P multi-threaded app * Create your own cryptocurrency app with full functionality* Implement blockchain technology on a P2P network from scratch using Java, JavaFX, and SQLWHO THIS BOOK IS FORAnyone with a basic level knowledge of: Java or similar object-oriented programming language, FXML or HTML or similar markup language, and SQLSPIRO BUZHAROVSKI is a full-stack software developer in the IT sector. He has a degree in mechanical engineering and has worked as an engineer in the oil and gas sector for more than six years. His interests include Java frameworks, blockchain, and the latest high-tech trends. Inspiration for this book came while working as a technical reviewer on the Apress book by Boro Sitnikovski, Introducing Blockchain with Lisp: Implement and Extend Blockchains with the Racket Language.1. Introduction to Blockchain . . . . . . . .1.1. Motivation and basic definitions . .1.2. Encryption . . . . . . . . . . . . . . .1.2.1. Functions . . . . . . . . . . . .1.2.2. Symmetric-key algorithm . .1.2.3. Asymmetric-key algorithm .1.3. Hashing . . . . . . . . . . . . . . . . .1.4. Smart contracts . . . . . . . . . . . .1.5. Bitcoin . . . . . . . . . . . . . . . . . .1.6. Example workflows . . . . . . . . . .Summary . . . . . . . . . . . . . . . . . . .2. Blockchain Core - Model . . . . . . . .2.1 Block.java . .2.2. Transaction.java . . . . . . . . . . . . . . .2.3. Wallet.java . . . . . . . . . . . . . . . . .Summary . . . . . . . . . . . . . . . . .3. Database Setup. . . . . . . .3.1. SQLite Database Browser Quick Setup .3.2. Blockchain.db3.3. Wallet.db . . . . . . . . . . . . . . . . . .3.4 JDBC Driver for SQLite setup3.5 Writing your App init() method.Summary . . . . . . . . . . . . . . . . . . .4. Service Layer Implementation. . . . . .4.1. BlockData.java44.2. WalletData.javaSummary . . . . . . . . . . . . . . . . .5. UI – View Layer. . . . . .5.1. SceneBuilder Quick Setup5.2. Creating Your Views3.2.1. MainWindow.fxml . . . . . . . . . . . . . . . .3.2.2. AddNewTransactionWindow.fxml . . . . . . . . . . . . . . . .5.3. Creating Your View Controllers5.3.1 MainWindowController.java5.3.1 AddNewTransactionController.javaSummary . . . . . . . . . . . . . . . . .6. Network Handlers – Networking Layer. . . . . .6.1. UI Thread6.2. Peer Client Thread6.3. Peer Server Handler – Multithreading requests 6.3.1 Peer Request Thread6.4. Mining ThreadSummary . . . . . . . . . . . . . . . . .
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“.
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