Programmierung
Build Your Own Test Framework
Learn to write better automated tests that will dramatically increase your productivity and have fun while doing so. This book is a build-your-own adventure designed for individual reading and for collaborative workshops.You will build an xUnit automated test framework using JavaScript: initially a clone of Jest, but adding a couple of neat features borrowed from RSpec, the genre-defining tool for behavior-driven development (BDD). Along the way, you will explore the philosophy behind automated testing best practices. The automated test runner is one of the most important innovations within software engineering. But for many programmers, automated testing remains a mystery, and knowing how to write good tests is akin to sorcery.As the chapters of this book unfold, you will see how the humble test runner is an elegant and simple piece of software. Each chapter picks a single feature to build, like the "it" function or the "beforeEach" block. It picks apart the theory of why the feature needs to exist, and how to use it effectively in your own test suites. Every chapter ends with a set of ideas for extension points should you wish to explore further, alone or in groups. The book culminates in an implementation of test doubles and mocks—one of the most difficult and misunderstood concepts within automated testing.By the end of the book, you will have gained a solid understanding of automated testing principles that you can immediately apply to your work projects.WHAT YOU'LL LEARN* Build an xUnit automated test framework* See how an automated test runner works* Understand the best practices for automated unit testing* Effectively use test doubles and mocksWHO THIS BOOK IS FORSoftware developers with JavaScript experience who are seeking to master the art of automated testing.Daniel Irvine is a freelance software developer based in London. He works with a variety of languages including C#, Clojure, JavaScript, and Ruby. When he’s not working, he spends time cooking, gardening and practicing yoga. He co-founded the Queer Code London meetup and is an active member of the European software craft community. PART 1: BUILDING THE CORE OF A TEST FRAMEWORKIn this part we build a barebones implementation of a test runner.CHAPTER 1: CREATING AN NPM PACKAGE OF MY VERY OWN,You will create a new NPM package for concise-test, including an entry-point for the test runner.CHAPTER 2: BUILDING IT TO DEFINE A TESTwe’ll implement the it function for defining tests, and start printing out some useful test run information on screen.CHAPTER 3: GROUPING TESTS WITH DESCRIBE,we’ll add support for grouping tests with the describe function, and we’ll continue to build out test reporting on screen.CHAPTER 4: PROMOTING CONCISENESS WITH BEFOREEACH AND AFTEREACHWe continue our quest for concise testing facilities with the addition of beforeEach and afterEach functions.CHAPTER 5: IMPROVING LEGIBILITY WITH EXPECT,We finish off the core of our API by building an abstraction over throw new Error.PART 2: CONSTRUCTING A USABLE FRAMEWORKIn this part we add features that you’ll use on a daily basis.CHAPTER 6: FORMATTING EXPECTATION ERRORSWe write a formatter for stack traces to help pinpoint failures quickly.CHAPTER 7. AUTOMATICALLY DISCOVERING TEST FILESWe’ll add test file discovery to our test runner, and add support for running a single file through a command line argument.CHAPTER 8: FOCUSING ON TESTS WITH IT.ONLY AND DESCRIBE.ONLY,We split out runner into two phases: a discovery phase and an execution phase. In between them, we insert a filter phase to support running only a subset of phases.CHAPTER 9: SUPPORTING ASYNCHRONOUS TESTS,We add the ability to wait on tests that return Promise objects, and timing out tests with it.timesOutAfter.CHAPTER 10: REPORTINGwe use a pub-sub model to build a plug-in system for reporters.PART 3: EXTENDING FOR POWER USERSIn this part we continue to add advanced features.CHAPTER 11: SHARING BEHAVIOR WITH IT.BEHAVESLIKE,We borrow an important feature from Ruby: inheritance for describe blocks, which gives us a flexible mechanism for removing duplication between test groups.CHAPTER 12: TAGGING TESTSWe create a mechanism for running a group of tests based on their tag.CHAPTER 13 : SKIPPING TESTSwe introduce a number of ways to skip tests, including tests without bodies, and it.skip plus describe.skip functions.CHAPTER 14 : RANDOMIZING TESTSWe add a runtime flag for randomizing the order of tests, which is a useful technique for catching invisible dependencies between tests.PART 4: TEST DOUBLES AND MOCKSChapter 15. Understanding test doubleswe create a function that can be used as a test spy and stub.CHAPTER 16. MODULE MOCKSWe create a system for mocking out entire modules, which is a useful technique when creating component doubles when testing React.
Interaction Design
A DELIGHTFUL, ENGAGING, AND COMPREHENSIVE OVERVIEW OF INTERACTION DESIGNEffective and engaging design is a critical component of any digital product, from virtual reality software to chatbots, smartphone apps, and more. In the newly updated sixth edition of Interaction Design: Beyond Human-Computer Interaction, a team of accomplished technology, design, and computing professors delivers an intuitive and instructive discussion of the principles underlying the design of effective interactive technologies. The authors discuss how to design and apply digital technologies in the real world, illustrated with numerous examples. The book explores the interdisciplinary foundations of interaction design, including skills from product design, computer science, human and social psychology, and others. The book builds on the highly successful fifth edition and draws on extensive new research and interviews with accomplished professionals and researchers in the field that reflect a rapidly-changing landscape. It is supported by a website hosting digital resources that add to and complement the material contained within. Readers will also find:* Explorations of the social and emotional components of interacting with apps, digital devices and computers* Descriptions about how to design, prototype, evaluate and construct technologies that support human-computer interaction* Discussions of the cognitive aspects of interaction design, as well as design and evaluation, including usability testing and expert reviews. An essential text for undergraduate and graduate students of human-computer interaction, interaction design, software engineering, web design, and information studies, Interaction Design will also prove to be indispensable for interaction design and user experience professionals. YVONNE ROGERS is the Director of the Interaction Centre at University College London as well as a Professor of Interaction Design. HELEN SHARP is Professor of Software Engineering at the Open University, UK. JENNIFER PREECE is Professor and Dean Emerita in the College of Information, Maryland’s iSchool – at the University of Maryland.
Practical OpenTelemetry
Learn the value that OpenTelemetry can bring to organizations that aim to implement observability best practices, and gain a deeper understanding of how different building blocks interact with each other to bring out-of-the-box, vendor-neutral instrumentation to your stack. With examples in Java, this book shows how to use OpenTelemetry APIs and configure plugins and SDKs to instrument services and produce valuable telemetry data. You’ll learn how to maximize adoption of OpenTelemetry and encourage the change needed in debugging workflows to reduce cognitive load for engineers troubleshooting production workloads.Adopting observability best practices across an organization is challenging. This book begins with a discussion of how operational monitoring processes widely followed for decades fall short at providing the insights needed for debugging cloud-native, distributed systems in production. The book goes on to show how the Cloud Native Computing Foundation’s OpenTelemetry project helps you standardize instrumentation and transport of telemetry signals, providing a common language for all observability tooling.YOU WILL LEARN* Why observability is a necessity in modern distributed systems* The value of OpenTelemetry for engineers and organizations * OpenTelemetry component specification and general design* Tracing, metrics, and logs APIs and SDKs, with examples in Java* OpenTelemetry Collectors and recommended transport and processing pipelines* How to adopt observability standards across an organizationWHO THIS BOOK IS FORSoftware engineers familiar with cloud-native technologies and operational monitoring who want to instrument and export telemetry data from their services; observability leads who want to roll out OpenTelemetry standards and best practices across their organizations; and Java developers who want a book with OpenTelemetry examples in that languageDANIEL GOMEZ BLANCO is a Principal Engineer at Skyscanner, leading their observability transformation across hundreds of services to ensure that travelers get a reliable and performant experience when booking their next holiday. He is an advocate of open standards and CNCF projects such as OpenTelemetry to back the instrumentation and collection of operational data. Daniel has experience working in organizations of all sizes, from international institutions such as CERN in Geneva, to London startups such as SKIPJAQ. His main focus has always been building software and adopting solutions to minimize the cognitive load required for engineers to support and operate production services. PART I. THE NEED FOR OBSERVABILITY WITH OPENTELEMETRY1. The Need for Observabilitya. Why Observability Mattersb. Context and Correlation2. How OpenTelemetry Enables Observabilitya. OpenTelemetry’s Missionb. The Power of Open Standardsc. The Shift In Vendor Added ValuePART II. OPENTELEMETRY COMPONENTS AND BEST PRACTICES3. OpenTelemetry Fundamentalsa. OpenTelemetry Specificationb. Semantic Conventions4. Auto-Instrumentationa. Resource SDKb. Instrumentation Libraries5. Context, Baggage, and Propagatorsa. Telemetry Context and the Context APIb. Baggage APIc. Cross-Service Context and the Propagators API6. Tracinga. What is a Distributed Trace?b. Tracing APIc. Tracing SDKd. Trace Context Propagation7. Metricsa. Measurements, Metrics and Time Seriesb. Metrics APIc. Metrics SDK8. Logginga. The Purpose of Logs for Observabilityb. Logging APIc. Logging SDKd. Integrations with Logging Frameworks9. Protocol and Collectora. Protocolb. Collector10. Sampling and Common Deployment Modelsa. Common Deployment Modelsb. Trace SamplingPART III. ROLLING OUT OPENTELEMETRY ACROSS YOUR ORGANISATION11. Maximizing Adoption by Minimizing Frictiona. Investing in Telemetry Enablementb. Adopting OpenTelemetry12. Adopting Observabilitya. Shifting Debugging Workflowsb. Expanding Contextc. Keeping Telemetry Valuable
Coding und Making mit Scratch und MakeyMakey
Scratch ist eine visuelle Programmiersprache, sie wurde von der Lifelong Kindergarten Group am MIT entwickelt. Viele neuere erziehungsorientierte Programmiersprachen nehmen sich das Design von Scratch als Vorbild (Snap!, Ozoblockly, Touchdevelop).Scratch ist so einfach in der Bedienung, dass bereits Volksschulkinder damit erste Erfahrungen im Programmieren machen können. Scratch läuft ab Version 2 im Browser, eine Installation ist nicht nötig. Die einzelnen Befehle werden per Drag & Drop zu Sequenzen verbunden, eine kindgerechte Bedienung steht im Vordergrund. Die Projekte werden online gespeichert und können veröffentlicht werden, so sind erste Ergebnisse schnell online verfügbar, aber auch ein lokales Speichern ist möglich.Mit Beiträgen von Bernhard Abfalter, Sabine Apfler, Moritz Brinnich, Elieser Grill, Duy Ho David Tran, Natalie Traxler und Andreas Weiner.Gerhard Brandhofer:HS-Prof. Mag. Dr. Gerhard Brandhofer, BEd hat eine Hochschulprofessur für Mediendidaktik und informatische Bildung an der PH Niederösterreich inne. Zu den Arbeitsschwerpunkten gehören die Planung, Lehre und Forschung im Bereich des Einsatzes von digitalen Medien im Unterricht der Primar- und Sekundarstufe Forschungsaktivitäten und Veröffentlichungen umfassen die Themenfelder der Nutzung digitaler Medien in der Schule wie auch in der Hochschule, die Bedingungen für gelingende informatische Bildung, die Implementierung visueller Programmiersprachen in der Schulbildung.
Angular (4. Auflg.)
Grundlagen, fortgeschrittene Themen und Best Practices. Inkl. RxJS, NgRx und a11y in aktueller 4. Auflage aus Februar 2023.Das große Praxisbuch zu Angular!Mit einem anspruchsvollen Beispielprojekt führen die Autoren Sie durch die Welt von Angular. Entwickeln Sie Schritt für Schritt eine umfangreiche modulare Single-Page-Anwendung und üben Sie Angular im praktischen Einsatz. Mit seinen umfangreichen Theorieteilen ist dieses Buch außerdem Ihr praktischer Begleiter im Entwicklungsalltag.Die Autoren sind erfahrene Workshopleiter, Entwickler und internationale Konferenzsprecher. In dieser vollständig überarbeiteten Auflage vermitteln sie die Best Practices aus ihrer täglichen Arbeit mit Angular. Aufgrund ihres Engagements rund um das Buch und Angular wurden Ferdinand und Johannes als Google Developer Experts (GDE) ausgezeichnet.Aus dem Inhalt:Reaktive Programmierung mit RxJSState Management mit Redux und NgRxTesting mit Jasmine, Karma, Jest und CypressModule und Standalone ComponentsRouting und GuardsHTTP und InterceptorsFormularverarbeitungDependency Injection und ServicesBarrierefreiheit (a11y)Internationalisierung (i18n)Progressive Web Apps (PWA)Erste Kenntnisse in JavaScript und HTML sind von Vorteil, aber keine Voraussetzung. Wer nicht mit TypeScript vertraut ist, findet im Buch eine fundierte Einführung.Auf der Website zum Buch werden außerdem regelmäßig Aktualisierungen und Neuigkeiten rund um Angular veröffentlicht.Über die Autoren:Ferdinand Malcher ist Google Developer Expert (GDE) und arbeitet als selbständiger Entwickler, Berater und Mediengestalter mit Schwerpunkt auf Angular, RxJS und TypeScript. Gemeinsam mit Johannes Hoppe hat er die Angular.Schule gegründet und bietet Schulungen zu Angular an.Danny Koppenhagen arbeitet als Softwarearchitekt und Entwickler. Sein Schwerpunkt liegt in der Frontend-Architektur und der Entwicklung von Enterprise Webanwendungen auf Basis von Node.js, TypeScript, Angular und Vue. Neben der beruflichen Tätigkeit ist Danny als Autor mehrerer Open-Source-Projekte aktiv.Johannes Hoppe ist Google Developer Expert (GDE) und arbeitet als selbständiger Trainer und Berater für Angular, .NET und Node.js. Zusammen mit Ferdinand Malcher hat er die Angular.Schule gegründet und bietet Workshops und Beratung zu Angular an. Johannes ist Organisator des Angular Heidelberg Meetup.Sie erreichen das Autorenteam auf Twitter unter @angular_buch.Mehr Infos und Kontaktmöglichkeiten finden Sie unter https://angular-buch.com/autoren.Zielgruppe: Webentwickler*innenJavaScript-Entwickler*innenApp-Entwickler*innen
Software Architect
A STRATEGIC STATE-OF-THE-ART SOFTWARE ARCHITECTURE MANUAL FOR ALL SKILL LEVELSIn Software Architect, veteran enterprise and solution architect Michael Bell delivers a hands-on playbook of best practices for aspiring and practicing software architects, seeking to improve their software design, integration, communication, presentation, and knowledge acquisition skills. He explores the career enablement, career planning, self-training, and self-improvement topics you’ll need to increase your ability to offer powerful and effective business and technological solutions. In the book, you’ll learn how to help companies promote business and technological transformation by implementing modern and first-class software design, deployment, integration, and operations. Software Architect also includes:* A modern software architect’s toolbox that includes best practices for multi-dimensional software design and integration in an enterprise quantum computing ecosystem * A breakdown of the various types of software architects, as well as useful self-assessments for aspiring and practicing professionals* Skill acquisition strategies for software architects along with strategic approaches to ace software architecture interviews An indispensable manual for aspiring to be architects, software architects-in-training, and practicing software architects. Software Architect is an essential read for anyone hoping to improve their ability to deliver robust business and technical solutions to enterprises everywhere. MICHAEL BELL is an enterprise and solution architect with hands-on experience in business and software architecture modeling. He has consulted for organizations including J.P. Morgan Chase, Citibank, Bank One, UBS-Paine Webber, American Express, AIG, and the US government. He is the best-selling author of software architecture books, and he offers a variety of enterprise integration solutions for back-end and customer-facing systems. Introduction xxiiiPART 1 SOFTWARE ARCHITECT CAPABILITY MODEL 1CHAPTER 1 SOFTWARE ARCHITECT CAPABILITY MODEL 3Software Architect Capability Model: Benefits 4How Should Organizations Utilize the Software Architect Capability Model? 4Why Create a Personal Software Architect Capability Model? 5Rudimentary Guiding Principles 6Software Architect Capability Model Creation Process 6Requirements Drive Architecture Solutions 7Requirements Issued by Problem and Solution Domain Entities 7How Do the Problem and Solution Domains Collaborate? 7Important Facts to Remember 9Create a Software Architect Capability Model in Five Steps 9Step 1: Provide Requirements and Specifications 10Business Requirements 10Technical Specifications 11Ensure Clear Requirements 11Step 2: Identify Software Architecture Practices 12Establish Architecture Practices 12Step 3: Establish Software Architecture Disciplines 13Apply Architecture Disciplines to Architecture Practices 14Applying Disciplines to the Application Architecture Practice 14Applying Disciplines for the Data Architecture Practice 16Step 4: Add Software Architecture Deliverables 17About Software Architecture Deliverables 17Add the Deliverables Section 18Step 5: Quantify Skill Competencies 21Quantifying Architecture Skills 22Measuring the Application Architect Skill Levels 22Measuring Data Architect Skill Levels 24Skill Competency Patterns for Architects 25How Can Organizations Utilize the Skill Competency Pattern? 26How an Individual Can Utilize the Skill Competency Pattern 27Interview Questions 28PART 2 SOFTWARE ARCHITECTURE CAREER PLANNING 29CHAPTER 2 TYPES OF SOFTWARE ARCHITECTS 31Business Needs for Technological Solutions 32Business Needs for Software Architecture: Strategic Collaboration 32How Does Software Architecture Respond to Business Needs? 33Business Needs for Software Architecture: Technological Mediation 33How Could Technological Mediation Efforts Be Utilized? 34Business Needs for Software Architecture: Technological Implementation 34How Does the Implementation of Software Products Meet Business Needs? 34Organizational Leading Software Architect Levels 35Ranking Leading Software Architects 35Collaboration Hierarchy of Leading Software Architects 36Level I: Enterprise Architect Responsibilities 38Enterprise Architect Summary of Responsibilities 38Enterprise Architect Responsibility Table 39Level II: Solution Architect Responsibilities 40Solution Architect Summary of Responsibilities 41Solution Architect Responsibility Table 42Level III: Application Architect Responsibilities 44Application Architect Summary of Responsibilities 44Application Architect Responsibilities Table 46Comparing Responsibilities of Leading Software Architects 48Types of Domain Software Architects 49Data Architect 49Data Architect Summary of Responsibilities 50Data Architect Responsibilities Table 51Cloud Architect 51Cloud Architect Summary of Responsibilities 54Cloud Architect Responsibilities Table 55Security Architect 57Security Architect Summary of Responsibilities 58Security Architect Responsibilities Table 60Business Architect 62Business Architect Summary of Responsibilities 62Business Architect Responsibilities Table 63Collaboration Between Leading Software Architects and Domain Software Architects 65Use Case I: Collaboration Between an Application Architect and a Data Architect 66Application Architect and Data Architect Collaboration Table 66Use Case II: Solution Architect and Security Architect 68Solution Architect and Security Architect Collaboration Table 68Use Case III: Business Architect and Enterprise Architect Collaboration 70Business Architect and Enterprise Architect Collaboration Table 70CHAPTER 3 CAREER PLANNING FOR SOFTWARE ARCHITECTS: A WINNING STRATEGY 73Software Architecture Career Planning Process 74Career Planning Step 1: Conduct Self- Discovery 75Discovery of Technological and Social Talents 75Career Planning Self- Discovery Subjects 76Career Planning Step 2: Pursue Research 76Formal Education, Training, and Certification 77Employment Opportunities and Interviews 77Subjects of Research 77Career Planning Step 3: Devise an Approach 78Setting Software Architecture Career Goals 78Setting Software Architecture Career Milestones 80Decision- Making 81Action Planning 82Career Planning Step 4: Plan Career Execution 85Use Case I: A Software Architecture Career Execution Plan with Alternative Tasks 85Use Case II: Optimized Software Architecture Execution Plan 88Self- Discovery Process: The Six Ws 89The “Why” 90The “Who” 91The “What” 92Self- Discovery Questions for Software Architecture Candidates 93Self- Discovery Queries for Software Architects 93The “Where” 94The “When” 95The “How” 96“How” Self- Queries for Software Architecture Applicants 97“How” Self- Questions for Practicing Software Architects 97Carving a Software Architecture Career Path 98The 4D Software Architecture Career Perspectives 99Social- Driven Career Perspective 100Social- Driven Career Chart 100Carve Out a Social- Driven Career Chart 101Social- Driven Career Path 102Create a Social- Driven Career Path 102Technology- Driven Career Perspective 103Technology- Driven Career Chart 104Create a Technology- Driven Career Chart 105Technical- Driven Career Path 106Develop a Technical- Driven Career Path 106Leadership- Driven Career Perspective 107Leadership- Driven Career Chart 108Create a Leadership- Driven Career Chart 109Leadership- Driven Career Path 110Develop a Leadership- Driven Career Path 110Strategy- Driven Career Perspective 112Strategy- Driven Career Chart 112Create a Strategy- Driven Career Chart 114Strategy- Driven Career Path 114Develop a Strategy- Driven Career Path 115CHAPTER 4 SELF- ASSESSMENT FOR SOFTWARE ARCHITECTS 117Social Intelligence 118Teamwork 118Partnership 119Self- consciousness 119Communication 120Networking 120Soft Skills 120Trust Building 121Learning from Others 121Negotiation 122Self- presentation 122Teleworking 123Fellowship 123Self- sufficiency 124Handling Customer Relationships 124Social Intelligence Skill Assessment 124Software Architecture Practice 126Software Architecture Strategy 126Software Architecture Vision 127Software Architecture Role 127System Integration 128Interoperability 128Software Reuse 129Distributed Architecture Model 129Federated Architecture Model 129Architecture Styles 130Architecture and Design Patterns 130Componentization 130Software Architecture Frameworks 131Software Development 131Software Architecture Practice Skill Assessment 132Leadership 133Managing Time 134Decision- Making 134Problem-solving 134Diversity, Equity, and Inclusion 135Responsibility and Accountability 135Hiring Preferences 136Creative Thinking 136Critical Thinking 136Being Proactive 137Establishment of Trust 137Administrative Duties 138Coaching and Training 138Team Building 139Resolving Conflicts 139Assessment of Leadership Competencies 140Strategy 141Software Architecture Strategy 142Strategic Thinking 142Problem Identification 142Problem-solving 143Abstraction 143Generalization 144Visualization 144Software Design Approaches 145Simplification 145Analytical Capabilities 145Influencing 146Promoting Culture 146Strategy Execution Plan 147Assessment of Strategic Competencies 147PART 3 SOFTWARE ARCHITECTURE TOOLBOX 149CHAPTER 5 EMPLOYING INNATE TALENTS TO PROVIDE POTENT ORGANIZATIONAL SOLUTIONS 151Innate Skills Promote Software Architecture Effectiveness 152Remember: Survival, Survival, Survival 152Consequences of Failing to Invoke Innate Talents 153Employ Chief Innate Talents to Become an Effective Software Architect 154The Power of Creativity 154The Benefits of Unleashing Software Architecture Creativity 155Unleash the Power of Software Architecture Creativity 155The Potency of Imagination 157The Benefits of Harnessing Imagination 158Unleash the Power of Imagination 159Software Design Aesthetic 162Technical Proficiency and Aesthetic Talents Drive Software Design 162The Chief Contribution of Design Aesthetic Talents to Software Architecture 163Curiosity Attributes 167The Contribution of Curiosity to Software Architecture 167The Influencing Facets of Curiosity on Software Architecture Practices 168CHAPTER 6 SOFTWARE ARCHITECTURE ENVIRONMENT CONSTRUCTION 173Benefits of the Software Architecture Environment Construction Discipline 174Must Haves: Problem Statements and Requirements 174Never Start a Software Design Project Without Understanding the Problems 175Never Start a Software Design Project Without Requirements 176Software Architecture Structures 176Micro Level: Multidimensional Structures of Software Implementations 176Macro Level: 3D Software Architecture Environment Structure 177Software Architecture Environment: Driven by an Uncontrolled Quantum Landscape Behavior 178Software Architecture Environment: An Intelligent Topological Space 179Deformation Aspects of a Multidimensional Software Architecture Environment 181Entanglement Effects in a Software Architecture Environment 182Software Architecture Environment Forces Drive Software Behavior 183Probability Assessment of Software Operations and Behavior 184Software Architecture Environment Positive and Negative Forces 184Software Architecture Environment Gravitational Forces 185The Impetus for Granting Software Architecture Gravitational Powers to Software Implementations 186Software Architecture Gravitational Force Intensity 187The Cost of Unbalanced Software Architecture Environment Gravitational Forces 187Competing Software Architecture Environment Forces 188Software Architecture Environment: A Survival Game Space 188Maintaining a Pragmatic Balance Between Competing Software Architecture Forces 189Mitigating the Competing Forces Challenge 190Software Architecture Environment Harmonizing and Disharmonizing Forces 190Chief Properties of Harmonizing Forces in a Software Architecture Environment 191Chief Properties of Disharmonizing Forces in a Software Architecture Environment 193Genetic Encoding of a Software Architecture Environment 194Difficulties of Restructuring a Software Architecture Environment 194Encoding a Software Architecture Environment 195Influences on Social, Behavioral, and Business Goals 195Software Architecture Environment Construction Life Cycle 196Software Architecture Environment Construction Process 197Creating a Software Architecture Environment Construction Balance Table 197Software Architecture Environment Construction Design Activities 199Use Case I: Software Architecture Environment Composition and Decomposition Design Activities 201Design- Time vs. Runtime Environment Composition and Decomposition Design Activities 201Composition and Decomposition Design Methods 202Composition and Decomposition Process Outline 203Use Case II: Software Architecture Environment Integration and Disintegration Design Activities 204When to Apply Integration and Disintegration Design Activities 205Integration and Disintegration Design Methods 205Integration and Disintegration Process Outline 206Use Case III: Software Architecture Environment Centralization and Decentralization Design Activities 208When to Employ the Software Environment Centralization and Decentralization Design Activities 208Centralization and Decentralization Design Methods 209Software Architecture Environment Centralization and Decentralization Process Outline 210Use Case IV: Software Architecture Environment Elasticity and Inelasticity Design Activities 211CHAPTER 7 WHEN TO EMPLOY ELASTICITY AND INELASTICITY DESIGN ACTIVITIES 212Elasticity and Inelasticity Design Methods 213Software Architecture Elasticity and Inelasticity Design Process Outline 214Use Case V: Software Architecture Environment Synchronization and Desynchronization Design Activities 215When to Employ Environment Synchronization and Desynchronization Design Activities 216Environment Synchronization and Desynchronization Design Methods 216Software Architecture Environment Synchronization and Desynchronization Design Process Outline 218Construction Laws of a Software Architecture Environment 219Best Practices for Software Architecture Environment Construction 220Structural Construction of Software Implementations in Multidimensional Environments 223Software Architecture Solids: Rudimentary Geometrical Design Structures 224Atomic Solid 225Composite Solid 227Monolithic Solid 228Interface Solid 229Pipe Solid 230Inclusive Utilization of Pipe Solids 231Exclusive Utilization of Pipe Solids 232Internal Utilization of Pipe Solids 233Data Solid 234Software Architecture Solids’ Attribute Summary 236Software Architecture Dimensional Model 237Software Architecture: Zero Dimension 238Software Architecture: One Dimension 239Software Architecture: Two Dimensions 240What Impacts the Length and Width Dimensions of a2D Software Structure? 241Software Architecture: Three Dimensions 242Volumes of 3D Software Structures 242Increase in Software Architecture Level of Specificity in a3D Computing World 243Software Population Sustainability in an Architecture Environment Space: A Capacity Planning Challenge 245Comparative Perspectives in a Software Architecture Space 2463D Software Structures in a Software Architecture Computing Space 247The Impetus for Establishing a 3D Software Architecture Space 247Chief Features of Software Architecture Computing Space 249Influences of Software Structures on Software Architecture Computing Space 250Relative Positions in a 3D Software Architecture Computing Space 250Coordinate Axes: Skeleton of a Software Architecture Computing Space 251Software Architecture Computing Space Logical Coordinate System 252Cardinal and Intercardinal Physical Directions in Software Architecture Computing Space 253Applying Cardinal and Intercardinal Directions to Software Architecture Computing Space 254Marrying a Logical Coordinate System with Cardinal and Intercardinal Physical Directions System 255Leveraging the Z- Axis to Create Floors in a Software Architecture Computing Space 256Distribution Styles of 3D Software Implementations in an Architecture Computing Space 257Federated Distribution Style 258Flooring Distribution Style 260Symmetrical and Asymmetrical Distribution Styles 261Symmetrical Distribution Style 261Asymmetrical Distribution Style 263Construction Life Cycle of Software Implementations 264Software Construction Process 265Creating a Software Construction Balance Table 265Software Construction Design Activities 266Use Case I: Thicken and Contract Design Activities 267When to Apply Thicken and Contract Design Activities 268Thicken and Contract Design Methods 269Software Structure Thickening and Contracting Process Outline 270Use Case II: Lengthen and Shorten Design Activities 272When to Apply the Lengthen and Shorten Design Activities 273Lengthen and Shorten Design Methods 273Software Structure Lengthening and Shortening Process Outline 275Use Case III: Layer and Delayer Design Activities 277When to Apply Layer and Delayer Design Activities 277Layer and Delayer Design Methods 278Layer and Delayer Process Outline 279Governing Laws for Software Construction in a 3D Computing World 281Best Practices for Constructing Software Implementations 282PART 4 SOFTWARE ARCHITECTURE INTERVIEW PREPARATIONS 285CHAPTER 8 PREPARING FOR A SOFTWARE ARCHITECTURE INTERVIEW: A WINNING STRATEGY 287Software Architecture Job Interview Strategy 288Preparing a Job Interview Defense Plan 288Preparing a Job Interview Attack Plan 289Software Architecture Job Interview Preparation Model 290Software Architecture Job Interview Defense Plan 291Study and Analyze the Job Description 291Start with Identifying the Scope of the Software Architecture Job Requirements 292Dive Deep into the Software Architect Job Description 293Start with Analyzing the Summary Portion of the Job Requirements 294Create a Findings Table Version I for the Job Description 295Next, Analyze the Responsibilities Portion of the Job Requirements 296Then, Update the Findings Table Version II of the Job Description 296Last, Analyze the Software Architect Skills Portion of the Job Requirements 297Do Not Forget to Update the Findings Table of the Job Description 298Create a Software Architect Skill Competency Model for the Job Description 299Skill Competency Model’s Requirements and Practices 300Skill Competency Model’s Disciplines 301Design Discipline’s Deliverables 301Cybersecurity Discipline Deliverables 301Products Selection and Evaluation Discipline’s Deliverables 302SDLC Discipline’s Deliverables 302The Competency Part of the Skill Competency Model 303Discover the Personal Knowledge Gap Before Attending a Job Interview 303Assess Whether the Next Software Architecture Job Is a Strategic Career Move 304Conduct a Software Architecture Mock Interview 305Prepare a Software Architecture Interview Cheat Sheet 306Prepare for Possible Software Architecture Interview Questions 307Software Architecture Job Interview Attack Plan 308Study the Hiring Organization’s Business 309Start by Finding Information About the Hiring Organization 309CHAPTER 9 LEVERAGING BUSINESS KNOWLEDGE DURING AN INTERVIEW 311Understand the Business Model 312Get Familiar with the Hiring Company’s Culture 314Conduct a Quick SWOT Analysis 315Understand the Hiring Organization’s Technology 316Technological Information Sources 316Discover the Environment’s Technology Stack 318Learn About the Development Technology Stack 319Study the Applications 320Identify Specific IT Projects 321Demonstrate Enterprise Architecture Knowledge of the Hiring Organization 321Adopt Software Architecture Lingo 323Use Design Patterns Vocabulary 323Use the Software Architecture Guidelines Lingo to Communicate Solutions 324Remember Software Architecture Tools 328Classification of Software Architecture Tools 329Especially Prepare for Architecture Visualization Tools Questions 332Get Familiar with Software Architecture Analysis and Evaluation Methods 333Be Aware of Early Architecture Evaluation Methods 334Be Aware of Late Architecture Evaluation Methods 335Talk About Software Architecture Analysis Standards 335An Outline for Software Architecture Job Interview Questions 337Behavioral Questions 338Communication 339Interpersonal Relationships 340Software Architecture Leadership 340Skill Assessment Questions 341Software Architecture Attributes Questions 342Software Architecture LifeCycle Questions 343Software Architecture Concepts Questions 346Design Building Blocks Concepts 347Employ Design Building Blocks Concepts to Depict Solutions 347Prepare for the “How to Design” Interview Questions 348Software Architecture Environment Concepts 349Business Concepts 351Consumer Concepts 352Architecture Style, Architecture Pattern, and Design Pattern Questions 353Architecture Patterns vs. Design Patterns 353Understand Architecture Styles 355Remember Contextual Hierarchy of Patterns 355Why Interviewers Ask Architecture and Design Pattern Questions 356Prepare for Architecture and Design Pattern Questions 357Problem-solving and decision- making Questions 358Embrace the Software Architecture Problem- Solving and Decision- Making Process 358Identifying Business Problems 358Attend to the Problem- Solving and Decision- Making Process 359Prepare for Problem- Solving and Decision- Making Questions 360Data- Related Questions 360Focus on Data Aspects Related to Software Architecture 361More Data- Related Interview Questions 361Production Environment Questions 362Characteristics of Software Architecture Environment Hosted in Production 363Production Environment-Related Questions 364Software Architecture Framework Questions 365Focus on Array of Framework Contributions 365Software Architecture Framework Questions 367Index 369
Natural Language Processing mit Transformern
Sprachanwendungen mit Hugging Face erstellenTransformer liefern hervorragende Ergebnisse bei der maschinellen Sprachverarbeitung und haben sich in den letzten Jahren zur vorherrschenden Architektur im Natural Language Processing (NLP) entwickelt. Dieses Praxisbuch zeigt Data Scientists und Programmierer*innen, wie sie NLP-Modelle mit Hugging Face Transformers, einer Python-basierten Deep-Learning-Bibliothek, trainieren und skalieren. Transformer kommen beispielsweise beim maschinellen Schreiben von Nachrichtenartikeln, bei der Verbesserung von Google-Suchanfragen oder bei Chatbots zum Einsatz.Lewis Tunstall, Leandro von Werra und Thomas Wolf, die die Transformers-Bibliothek von Hugging Face mitentwickelt haben, erklären in diesem Buch, wie Transformer-basierte Modelle funktionieren und wie Sie sie in Ihre Anwendungen integrieren. Sie erfahren, wie Transformer für eine Vielzahl von Aufgaben erfolgreich eingesetzt werden können.Erstellen, debuggen und optimieren Sie Transformer-Modelle für zentrale NLP-Aufgaben wie Textklassifizierung, Named Entity Recognition oder Question AnsweringLernen Sie, wie Transformer für sprachenübergreifendes Transfer Learning verwendet werdenWenden Sie Transformer auf reale Anwendungsfälle an, bei denen nur auf wenige gelabelte Daten zurückgegriffen werden kannOptimieren Sie Transformer-Modelle für das Deployment mit Techniken wie Distillation, Pruning und QuantisierungTrainieren Sie Transformer von Grund auf und lernen Sie, wie sie auf mehreren GPUs und verteilten Umgebungen skalierenÜber die Autoren:Lewis Tunstall ist Machine Learning Engineer bei Hugging Face. Der Schwerpunkt seiner Arbeit liegt derzeit auf der Entwicklung von Tools für die NLP-Community und darauf, Menschen zu schulen, diese effektiv zu nutzen.Leandro von Werra ist Machine Learning Engineer im Open-Source-Team von Hugging Face. Er konzentriert sich hauptsächlich auf Modelle, die Code generieren können, und auf die Zusammenarbeit mit der Community.Thomas Wolf ist Chief Science Officer und Mitgründer von Hugging Face. Sein Team hat sich der Aufgabe verschrieben, die KI-Forschung voranzutreiben und sie weiter zu demokratisieren.
Java von Kopf bis Fuß (3. Auflage)
Eine abwechslungsreiche Entdeckungsreise durch die objektorientierte Programmierung, jetzt in aktualisierter 3. Auflage aus Februar 2023.»Java von Kopf bis Fuß« – jetzt vollständig überarbeitet und aktualisiert – ist eine umfassende Entdeckungsreise durch Java und die objektorientierte Programmierung. Mit diesem Buch lernen Sie die Sprache mit einer einzigartigen Methode: Sie knacken Rätsel, puzzeln und lösen Kriminalfälle, schreiben aber auch Unmengen von Java-Code. So lernen Sie schnell die Grundlagen von Java und fortgeschrittene Themen wie Lambdas, Streams, Generics, Threading, Networking und erkunden die gefürchtete Desktop-GUI. Wenn Sie bereits Erfahrung mit einer anderen Programmiersprache haben, wird dieses Buch Ihrem Gehirn modernere Ansätze der Programmierung präsentieren – das schlankere, schnellere und leichter zu wartende Java von heute.Dieses Workbook ist inhaltlich und visuell ein Feuerwerk. Es macht Spaß und bringt Ihr Gehirn auf Trab: Statt einschläfernder Bleiwüsten werden verschiedenste Textformen und Selbstlernkontrollen verwendet, die Ihnen das Wissen direkt ins Hirn spielen. Spätestens, wenn es heißt »Spitzen Sie Ihren Bleistift«, wird klar, dass hier Mitmachen gefragt ist.Autoren:Kathy Sierra interessiert sich für Lerntheorie seit ihrer Zeit als Spieleentwicklerin für Virgin, MGM und Amblin’ und als Dozentin für New Media Authoring an der UCLA. Sie war Master-Java-Trainerin für Sun Microsystems, und sie gründete JavaRanch.com (jetzt CodeRanch.com), das in den Jahren 2003 und 2004 den Jolt Cola Productivity Award gewann. Im Jahr 2015 erhielt sie den Electronic Frontier Foundation’s Pioneer Award für ihre Arbeit zur Schaffung kompetenter Nutzer und den Aufbau nachhaltiger Gemeinschaften.In jüngster Zeit konzentriert sich Kathy auf modernste Bewegungswissenschaften und das Coaching zum Erwerb von Fähigkeiten, bekannt als Ecological Dynamics oder „Eco-D“. Ihre Arbeit, bei der sie Eco-D für das Training von Pferden einsetzt, führt zu einem weitaus humaneren Ansatz in der Reitkunst, was die einen erfreut (und die anderen, traurigerweise, verwirrt). Die Pferde, die das Glück haben, dass ihre Besitzer Kathys Ansatz anwenden, sind zufriedener, autonomer, gesünder und sportlicher als ihre traditionell trainierten Artgenossen.Bevor Bert Bates Autor wurde, war er Entwickler, spezialisiert auf KI der alten Schule (hauptsächlich Expertensysteme), Echtzeit-Betriebssysteme und komplexe Planungssysteme. Im Jahr 2003 schrieben Bert und Kathy „Head First Java“ und starteten die Head-First-Reihe. Seitdem hat er weitere Java-Bücher geschrieben und Sun Microsystems und Oracle bei vielen ihrer Java-Zertifizierungen beraten. Außerdem hat er Hunderte von Autor:innen und Lektor:innen darin geschult, Bücher zu schreiben, die gute Lerninhalte bieten.Bert ist Go-Spieler und hat 2016 mit Entsetzen und Faszination zugesehen, wie AlphaGo Lee Sedol besiegt hat. In letzter Zeit nutzt er Eco-D (Ecological Dynamics), um sein Golfspiel zu verbessern und seinen Papagei Bokeh zu trainieren. - Bert hat das Privileg, Trisha Gee seit mehr als acht Jahren zu kennen, und die Head-First-Reihe hat das große Glück, sie zu den Auto:innen zu zählen.Trisha Gee arbeitet seit 1997 mit Java, als ihre Universität zukunftsorientiert genug war, diese „strahlend neue“ Sprache für den Informatikunterricht einzuführen. Seitdem hat sie als Entwicklerin und Consultant Java-Anwendungen für eine Reihe von Branchen entwickelt, darunter das Bankwesen, die Fertigung und gemeinnützige Organisationen. Trisha möchte all das weitergeben, was sie in diesen Jahren als Entwicklerin auf die harte Tour gelernt hat. Deshalb wurde sie Developer Advocate, schreibt Blogbeiträge, spricht auf Konferenzen und erstellt Videos, um ihr Wissen weiterzugeben. Sie verbrachte fünf Jahre als Java Developer Advocate bei JetBrains und weitere zwei Jahre als Leiterin des Teams „JetBrains Java Advocacy“. Während dieser Zeit hat sie viel über die Probleme gelernt, mit denen Java-Entwickler konfrontiert sind. Trisha hat in den letzten acht Jahren immer wieder mit Bert über die Aktualisierung von Head First Java gesprochen! Sie erinnert sich gerne an die wöchentlichen Telefongespräche mit Bert; der regelmäßige Kontakt mit einem sachkundigen und warmherzigen Menschen wie Bert half ihr, bei gesundem Verstand zu bleiben. Der Ansatz von Bert und Kathy, das Lernen zu fördern, ist der Kern dessen, was sie seit fast zehn Jahren zu tun versucht.Zielgruppe:Java-Einsteiger*innen mit Grundkenntnissen in einer anderen Sprache
Explainable AI Recipes
Understand how to use Explainable AI (XAI) libraries and build trust in AI and machine learning models. This book utilizes a problem-solution approach to explaining machine learning models and their algorithms.The book starts with model interpretation for supervised learning linear models, which includes feature importance, partial dependency analysis, and influential data point analysis for both classification and regression models. Next, it explains supervised learning using non-linear models and state-of-the-art frameworks such as SHAP values/scores and LIME for local interpretation. Explainability for time series models is covered using LIME and SHAP, as are natural language processing-related tasks such as text classification, and sentiment analysis with ELI5, and ALIBI. The book concludes with complex model classification and regression-like neural networks and deep learning models using the CAPTUM framework that shows feature attribution, neuron attribution, and activation attribution.After reading this book, you will understand AI and machine learning models and be able to put that knowledge into practice to bring more accuracy and transparency to your analyses.WHAT YOU WILL LEARN* Create code snippets and explain machine learning models using Python* Leverage deep learning models using the latest code with agile implementations* Build, train, and explain neural network models designed to scale* Understand the different variants of neural network models WHO THIS BOOK IS FORAI engineers, data scientists, and software developers interested in XAIPRADEEPTA MISHRA is the Director of AI, Fosfor at L&T Infotech (LTI). He leads a large group of data scientists, computational linguistics experts, and machine learning and deep learning experts in building the next-generation product—Leni—which is the world’s first virtual data scientist. He has expertise across core branches of artificial intelligence, including autonomous ML and deep learning pipelines, ML ops, image processing, audio processing, natural language processing (NLP), natural language generation (NLG), design and implementation of expert systems, and personal digital assistants (PDAs). In 2019 and 2020, he was named one of "India's Top 40 Under 40 Data Scientists" by Analytics India magazine. Two of his books have been translated into Chinese and Spanish, based on popular demand.Pradeepa delivered a keynote session at the Global Data Science Conference 2018, USA. He delivered a TEDx talk on "Can Machines Think?", available on the official TEDx YouTube channel. He has mentored more than 2,000 data scientists globally. He has delivered 200+ tech talks on data science, ML, DL, NLP, and AI at various universities, meetups, technical institutions, and community-arranged forums. He is a visiting faculty member to more than 10 universities, where he teaches deep learning and machine learning to professionals, and mentors them in pursuing a rewarding career in artificial intelligence.Chapter 1: Introduction to Explainability Library InstallationsChapter Goal: This chapter is to understand various XAI library installations process and initialization of libraries to set up the explainability environment.No of pages: 15-20 pagesChapter 2: Linear Supervised Model ExplainabilityChapter Goal: This chapter aims at explaining the supervised linear models as regression and classification and related issues.No of pages: 20-25Chapter 3: Non-Linear Supervised Learning Model ExplainabilityChapter Goal: This chapter explains the use of XAI libraries to explain the decisions made by non-linear models for regression and classification.No of pages : 20-25Chapter 4: Ensemble Model for Supervised Learning ExplainabilityChapter Goal: This chapter explains the use of XAI to explain the decisions made by ensemble models in regression and classification scenarios.No of pages: 20-25Chapter 5: Explainability for Natural Language ModelingChapter Goal: In this chapter, we are going to use XAI for natural language processing, pre-processing, and feature engineering.No of pages: 15-20Chapter 6: Time Series Model ExplainabilityGoal: The objective of this chapter is to explain the forecast using XAI librariesNo of Pages: 10-15Chapter 7: Deep Neural Network Model ExplainabilityGoal: Using XAI libraries to explain the decisions made by Deep Learning modelsNo of Pages: 20-25
VBA mit Access
Wie Sie mithilfe von VBA Access-Datenbanken gezielt im Hinblick auf Ihre Anforderungen optimieren, erfahren Sie in diesem Buch von Bernd Held. Er gehört zu den bekanntesten deutschsprachigen VBA-Spezialisten, viele seiner Bücher sind Bestseller. Nach einer grundlegenden Einführung in die Programmierung mit VBA lernen Sie die zentralen Objekte in Access (Tabellen, Abfragen etc.) intensiv kennen und erfahren, wie Sie aus Access auf Excel oder Word zugreifen. Außerdem profitieren Sie von der umfassenden Behandlung aller relevanten Sicherheitstechniken, mit denen Sie Datenbanken und Daten schützen. Damit Ihre Datenbanken intuitiv benutzbar sind und als eigenständige Datenbankanwendungen funktionieren, widmet sich ein eigener Teil der Programmierung von Benutzeroberflächen. Ein Troubleshooting-Kapitel und über 600 geprüfte Makros zum Download runden das Angebot ab. Geeignet für Access 2021, Access in Microsoft 365 sowie alle Vorgängerversionen bis Access 2010. Aus dem Inhalt: Grundsätzliches zur ProgrammierungVariablen, Konstanten und DatentypenDie wichtigsten Sprachelemente in AccessEin Streifzug in die Welt der ObjekteTabellen programmierenAbfragen programmierenProgrammierung von Dialogen, Steuerelementen und FormularenBerichte erstellen und programmierenEreignisse in Access programmierenAccess im Zusammenspiel mit OfficeAPI-Funktionen einsetzenDatenbanken und Quellcode schützenVBE-Programmierung in AccessAnwendungen optimieren und reparierenAccess und das InternetAccess 2016/2019/2021-Ribbons programmierenFAQ für Access-Entwickler Vorwort ... 21 1. Grundsätzliches zur Programmierung ... 25 1.1 ... Wie gehe ich von Anfang an richtig vor? ... 26 1.2 ... Die Entwicklungsumgebung von Access ... 28 1.3 ... Hilfsmittel für die Programmierung ... 33 1.4 ... Die Fenster und die Testumgebung ... 42 1.5 ... Weitere Einstellungen ... 49 2. Variablen, Konstanten und Datentypen ... 53 2.1 ... Regeln für die Syntax von Variablen ... 54 2.2 ... Variablen am Beginn der Prozedur deklarieren ... 54 2.3 ... Die verschiedenen Variablentypen ... 55 2.4 ... Variablendeklarationen erzwingen ... 57 2.5 ... Die wichtigsten Variablentypen ... 58 2.6 ... Noch kürzere Deklaration von Variablen ... 60 2.7 ... Die Reddick-Namenskonvention ... 60 2.8 ... Variablendeklaration mit »DefType« ... 62 2.9 ... Aufzählungstypen (»Enum«-Anweisung) ... 63 2.10 ... Konstanten verwenden ... 64 2.11 ... Systemkonstanten einsetzen ... 65 3. Die wichtigsten Sprachelemente in Access ... 85 3.1 ... Prozeduren ... 85 3.2 ... Verzweigungen/Bedingungen ... 96 3.3 ... Die Anweisung »Select Case« für mehr Übersicht ... 103 3.4 ... Schleifen in Access einsetzen ... 106 3.5 ... »With«-Anweisungen ... 119 3.6 ... VBA-Funktionen einsetzen ... 120 3.7 ... Umwandlungsfunktionen ... 153 3.8 ... Die »Is«-Funktionen in VBA ... 160 3.9 ... Operatoren ... 178 3.10 ... Eigene Funktionen schreiben ... 182 4. Ein Streifzug in die Welt der Objekte ... 201 4.1 ... Das »Application«-Objekt ... 201 4.2 ... Das Objekt »AccessObject« ... 209 4.3 ... Das Objekt »CodeData« ... 213 4.4 ... Das Objekt »DoCmd« ... 214 4.5 ... Integrierte Dialoge einsetzen ... 221 4.6 ... Das Objekt »FileSystemObject« ... 228 5. Tabellen programmieren ... 243 5.1 ... Tabellen bearbeiten mit »DoCmd« ... 244 5.2 ... Tabellen mit ADO programmieren ... 253 5.3 ... SQL-Anweisungen ... 257 5.4 ... Tabellenstrukturen mit ADOX ermitteln ... 289 5.5 ... Datenbanken suchen und dokumentieren ... 299 6. Abfragen programmieren ... 303 6.1 ... Abfragetypen ... 303 6.2 ... Abfragen durchführen ... 305 6.3 ... Abfragen mit SQL generieren ... 307 6.4 ... Aktualisierungsabfrage -- Artikelnamen ändern ... 307 6.5 ... Anfügeabfrage -- Mitarbeiter hinzufügen ... 310 6.6 ... Löschabfrage ausführen ... 312 6.7 ... Tabellenerstellungsabfrage durchführen ... 316 6.8 ... Datendefinitionsabfragen durchführen ... 318 6.9 ... Daten zusammenführen ... 327 6.10 ... Abfragen mit ADO programmieren ... 330 7. Programmierung von Dialogen, Steuerelementen und Formularen ... 341 7.1 ... Das Meldungsfeld »MsgBox« ... 342 7.2 ... Die Eingabemaske »InputBox« ... 346 7.3 ... Formulare erstellen ... 349 8. Berichte erstellen und programmieren ... 441 8.1 ... Berichtsarten in Access ... 441 8.2 ... Der Berichtsaufbau ... 442 8.3 ... Berichte entwerfen ... 443 8.4 ... Berichte bearbeiten mit »DoCmd« ... 444 8.5 ... Berichte formatieren ... 451 8.6 ... Berichte identifizieren ... 457 8.7 ... Berichte erstellen ... 464 9. Ereignisse in Access programmieren ... 483 9.1 ... Das Ereignis »Form_Open« ... 484 9.2 ... Das Ereignis »Form_Close« ... 487 9.3 ... Das Ereignis »Form_Load« ... 490 9.4 ... Das Ereignis »Form_Current« ... 492 9.5 ... Das Ereignis »Form_AfterInsert« ... 496 9.6 ... Das Ereignis »Form_BeforeInsert« ... 499 9.7 ... Das Ereignis »Form_BeforeUpdate« ... 502 9.8 ... Das Ereignis »Form_AfterUpdate« ... 508 9.9 ... Das Ereignis »Form_Delete« ... 508 9.10 ... Das Ereignis »Form_Dirty« ... 511 9.11 ... Das Ereignis »BeforeDelConfirm« ... 512 9.12 ... Das Ereignis »Form_AfterDelConfirm« ... 513 9.13 ... Das Ereignis »Form_Activate« ... 514 9.14 ... Das Ereignis »Form_Deactivate« ... 517 9.15 ... Das Ereignis »Form_Resize« ... 517 9.16 ... Das Ereignis »Form_DblClick« ... 519 9.17 ... Das Ereignis »Click« ... 523 9.18 ... Die Ereignisse »MouseDown« und »MouseUp« ... 524 9.19 ... Das Ereignis »MouseMove« ... 530 9.20 ... Das Ereignis »Schaltfläche_Click« ... 532 9.21 ... Die Ereignisse »GotFocus« und »LostFocus« ... 532 9.22 ... Die »Key«-Ereignisse ... 533 9.23 ... Das Ereignis »Steuerelement_BeforeUpdate« ... 537 9.24 ... Das Ereignis »Steuerelement_Enter« ... 543 9.25 ... Das Ereignis »Steuerelement_Exit« ... 545 9.26 ... Die Reihenfolge der Ereignisse ... 546 10. Access im Zusammenspiel mit Office ... 549 10.1 ... Textdateien im Zugriff von Access ... 550 10.2 ... Access im Zusammenspiel mit Word ... 564 10.3 ... Outlook und Access ... 574 10.4 ... Access im Duett mit Excel ... 596 11. API-Funktionen einsetzen ... 627 11.1 ... Das CD-ROM-Laufwerk ermitteln ... 628 11.2 ... Den Namen des Anwenders ermitteln ... 631 11.3 ... Das CD-ROM-Laufwerk bedienen ... 632 11.4 ... Die Bildschirmauflösung ermitteln (nur 32 Bit) ... 632 11.5 ... Ist ein externes Programm gestartet? ... 633 11.6 ... Ein externes Programm aufrufen ... 634 11.7 ... Wie lange läuft ein externes Programm (nur 32 Bit)? ... 634 11.8 ... Access schlafen schicken (32/64 Bit) ... 636 11.9 ... Verzeichnisse erstellen ... 637 11.10 ... Verzeichnis löschen ... 638 11.11 ... Verzeichnisbaum anzeigen und auswerten (nur 32 Bit) ... 638 11.12 ... Die Windows-Version ermitteln ... 639 11.13 ... Windows-Verzeichnis ermitteln (nur 32 Bit) ... 641 11.14 ... Windows-Systemverzeichnis ermitteln (nur 32 Bit) ... 641 11.15 ... Das temporäre Verzeichnis ermitteln (nur 32 Bit) ... 642 11.16 ... Das aktuelle Verzeichnis ermitteln (nur 32 Bit) ... 643 11.17 ... Windows-Infobildschirm anzeigen ... 643 11.18 ... Access-Verzeichnis ermitteln ... 644 11.19 ... Standardverzeichnis festlegen (nur 32 Bit) ... 644 11.20 ... Dateityp und Anwendung ermitteln ... 645 11.21 ... Kurze Pfadnamen ermitteln (nur 32 Bit) ... 646 11.22 ... Den Computernamen ermitteln ... 647 11.23 ... Texte mit API-Funktionen konvertieren ... 647 11.24 ... Die Zwischenablage löschen ... 648 11.25 ... Soundkarte checken ... 649 11.26 ... Sounds per API-Funktion ausgeben (nur 32 Bit) ... 649 11.27 ... PC piepsen lassen ... 649 11.28 ... Tasten abfangen (nur 32 Bit) ... 650 11.29 ... Dateien suchen ... 651 11.30 ... Dateiinformationen auslesen ... 652 11.31 ... Ist die Internetverbindung aktiv? ... 654 11.32 ... Cursorposition in Pixeln angeben (nur 32 Bit) ... 655 12. Datenbanken und Quellcode schützen und pflegen ... 661 12.1 ... Ihre Access-Lösung mithilfe von Startparametern absichern ... 661 12.2 ... Eine ACCDE-Datenbank erstellen ... 663 12.3 ... Eine Datenbank über ein Kennwort schützen ... 663 12.4 ... Quellcode schützen ... 670 12.5 ... Eine Datenbank komprimieren und reparieren ... 671 13. VBE-Programmierung in Access ... 675 13.1 ... Die VBE-Bibliothek einbinden ... 676 13.2 ... Weitere Bibliotheken einbinden oder entfernen ... 678 13.3 ... Fehlerhafte Verweise ermitteln ... 680 13.4 ... In den VBE springen ... 681 13.5 ... Objektbibliotheken auslesen ... 681 13.6 ... Neue Module einfügen ... 682 13.7 ... Modul(e) löschen ... 683 13.8 ... Prozedur(en) löschen ... 684 13.9 ... Einzelne Texte oder Befehle im Quellcode finden ... 686 13.10 ... Module mit Quellcode versorgen (Import) ... 689 13.11 ... Prozeduren sichern (Export) ... 692 13.12 ... Module drucken ... 693 13.13 ... »Lines Of Code« ermitteln ... 695 13.14 ... Identifikation von VB-Komponenten ... 696 13.15 ... Prozeduren auflisten ... 697 13.16 ... Eine eigene VBA-Datenbank anlegen ... 701 14. Anwendungen optimieren ... 707 14.1 ... Die automatische Leistungsanalyse ... 707 14.2 ... Datenbanken und Quellcode dokumentieren ... 709 14.3 ... Tabellen optimal anlegen ... 711 14.4 ... Die richtigen Befehle ... 712 15. Access und das Internet ... 717 15.1 ... E-Mail verschicken ... 717 15.2 ... Tabellen in Internetformate transferieren ... 738 16. Ribbons programmieren ... 741 16.1 ... Programmierung über ein XML-Markup ... 742 16.2 ... Weitere wichtige Quellen und Hilfen ... 748 17. FAQ für Access-Entwickler ... 751 17.1 ... Wie hänge ich einer Tabelle ein Feld an? ... 752 17.2 ... Wie verhindere ich, dass ein Formular geschlossen wird? ... 753 17.3 ... Wie frage ich alle Tabellen einer geschlossenen Datenbank ab? ... 754 17.4 ... Wie lege ich in einem bestimmten Verzeichnis eine neue Datenbank automatisch an? ... 756 17.5 ... Wie verlinke ich eine Tabelle aus einer anderen Datenbank? ... 758 17.6 ... Wie normiere ich Telefonnummern in Tabellen? ... 759 17.7 ... Wie dokumentiere ich eine komplette Datenbank? ... 761 17.8 ... Wie prüfe ich, ob eine bestimmte Tabelle existiert? ... 762 17.9 ... Wie prüfe ich, ob ein bestimmtes Feld in einer Tabelle angelegt ist? ... 764 17.10 ... Wie führe ich eine SQL-Abfrage auf eine andere Datenbank aus? ... 765 17.11 ... Wie ermittle ich alle verfügbaren Drucker? ... 766 17.12 ... Wie schreibe ich bestimmte Feldinhalte einer Tabelle in eine Textdatei? ... 767 17.13 ... Wie transferiere ich eine Access-Tabelle nach Word? ... 769 17.14 ... Wie lege ich eine Parameterabfrage automatisch an? ... 772 17.15 ... Wie greife ich auf Tabelleneigenschaften einer Datenbank zu? ... 773 17.16 ... Wie frage ich die beiden Extremwerte einer Spalte in einer Tabelle ab? ... 774 17.17 ... Wie führe ich eine Durchschnittsberechnung durch? ... 776 17.18 ... Wie erstelle ich eine Unikatliste? ... 777 17.19 ... Wie ermittle ich die Gesamtsumme für ein Tabellenfeld? ... 779 17.20 ... Wie führe ich eine bedingte Summierung durch? ... 780 17.21 ... Wie lese ich über eine ID den dazugehörigen Lieferanten aus? ... 781 Index ... 783
Software Engineering (4. Auflg.)
Grundlagen, Menschen, Prozesse, TechnikenDas Buch vermittelt die Grundlagen, Erfahrungen und Techniken, die den Kern des Software Engineerings bilden. Es ist als Material zu Vorlesungen über Software Engineering konzipiert. Auch für Praktiker, die mit der Softwareentwicklung und -bearbeitung und den dabei auftretenden Problemen vertraut sind, ist das Buch sehr gut geeignet, um die Kenntnisse im Selbststudium zu ergänzen und zu vertiefen. Der Inhalt des Buches ist in fünf Hauptteile gegliedert:GrundlagenMenschen und ProzesseDaueraufgaben im SoftwareprojektTechniken der SoftwarebearbeitungVerwaltung und Erhaltung von SoftwareAuf die Ausbildung zukünftiger Software Engineers wird ebenfalls eingegangen. Ergänzende Informationen sind auf der Webseite der Autoren verfügbar: https://se-buch.de.Die 4. Auflage enthält neben vielen kleinen Verbesserungen und Aktualisierungen neue Themen wie Schätzung in agilen Projekten, agile Skalierung, Microservices, Domain-Driven Design und automatische Software-Auslieferung. Autoren:Jochen Ludewig, Horst LichterProf. Dr. rer. nat. Jochen Ludewig geboren 1947 in Hannover. Studium der Elektrotechnik (TU Hannover) und Informatik (TU München); Promotion 1981. 1975 bis 1980 Gesellschaft für Kernforschung, Karlsruhe, dann Brown Boveri Forschungszentrum in Baden/Schweiz. 1986 Assistenzprofessor an der ETH Zürich, 1988 Ruf auf den neuen Lehrstuhl Software Engineering an der Universität Stuttgart. Arbeitsgebiete: Softwareprojekt-Management, Software-Prüfung und Software-Qualität, Software-Wartung. Ab 1996 Konzeption und Aufbau des Diplomstudiengangs Softwaretechnik, der inzwischen in einen Bachelor- und einen Masterstudiengang umgewandelt wurde. Seit 2009 Fellow der Gesellschaft für Informatik (GI).Prof. Dr. rer. nat. Horst Lichter geboren 1960 in Trier. Studium der Informatik und Betriebswirtschaftslehr (TU Kaiserslautern). Wissenschaftlicher Mitarbeiter (ETH Zürich und Universität Stuttgart), Promotion 1993. Anschließend Schweizerische Bankgesellschaft Zürich und ABB Forschungszentrum Heidelberg. 1998 Ruf an die RWTH Aachen University, Leiter des Lehr- und Forschungsgebiets Software-Konstruktion. Arbeitsgebiete: Software-Architektur, Qualitätssicherung, Software-Evolution. Seit 2005 Lecturer an der Thai German Graduate School of Engineering (TGGS) in Bangkok. Von 2018-2021 Adjunct Lecturer an der Universiti Teknologi Petronas (UTP) Malaysia.Zielgruppe:Praktiker*innen und Manager*innen mit Verantwortung für Software-ProjekteStudierendeLehrende
GitHub For Dummies
GET MORE OUT OF YOUR CODING WITH GITHUBFor today’s coders, GitHub is a must. The world’s largest software development platform, GitHub helps developers store, track, and collaborate on software projects. In this easy-to-follow Dummies guide, you’ll find insight into creating repositories, establishing projects, collaborating, incorporating open-source resources, and establishing yourself as a valued member of the GitHub community. With a working knowledge of GitHub, you’ll be a better, more employable programmer. The simple instructions and interactive examples in this book will get you there quickly.* Get the instructions you need for using GitHub to collaborate on software projects* Become more attractive to employers with knowledge and experience in the largest development platform* Set up GitHub Desktop, create a repository, and launch your first project* Use GitHub Skills courses to learn new tricks, for beginners to prosYou’ve learned how to write a little code—now learn how to share it with GitHub. SARAH GUTHALS, PHD is the Director of Developer Relations for Sentry, and previously worked at GitHub as an Engineering Manager. She is coauthor of Helping Kids with Coding For Dummies. Introduction 1PART 1: GETTING STARTED WITH GITHUB.COM 5Chapter 1: Understanding the Git in GitHub 7Chapter 2: Setting Up Your Collaborative Coding Environment 25PART 2: STARTING YOUR FIRST SOLO PROJECT 35Chapter 3: Introducing GitHub Repositories 37Chapter 4: Setting Up a GitHub Website Repo 57Chapter 5: Creating a Website with GitHub Pages 73PART 3: CONTRIBUTING TO YOUR FIRST PROJECT 91Chapter 6: Forking GitHub Repositories 93Chapter 7: Writing and Committing Code 109Chapter 8: Working with Pull Requests 129PART 4: MANAGING AND CONTRIBUTING TO LARGE PROJECTS 149Chapter 9: Exploring and Contributing to OSS 151Chapter 10: Starting Your Own OSS 165Chapter 11: Inner-Source Your Code on GitHub 185PART 5: MAKING GITHUB WORK FOR YOU 203Chapter 12: Collaborating Outside of GitHub 205Chapter 13: GitHub Workflow Integrations 219Chapter 14: Personalizing GitHub 233PART 6: THE GITHUB ECOSYSTEM 247Chapter 15: Exploring the GitHub Marketplace 249Chapter 16: GitHub and You 259Chapter 17: Attending Events 267PART 7: THE PART OF TENS 277Chapter 18: Ten Ways to Level Up on GitHub 279Chapter 19: Ten Ways to Improve Your Development Workflow 291Chapter 20: Ten Tips for Being an Effective Community Member 299Index 307
Pro Kotlin Web Apps from Scratch
Build production-grade web apps from scratch – without using frameworks – with Kotlin on the Java platform. You’ll learn how to use and compose libraries, how to choose between different libraries, and the benefits of explicit and straight-forward code, vs. the implicit magic, conventions, and inversion of control you often see in frameworks.The book teaches the Kotlin language by building production-ready Kotlin code. You’ll gain a deep understanding of the idiomatic use of the Kotlin language along with knowledge of how to apply Kotlin in production-grade web apps. The book also bridges the gap between building from scratch and using existing frameworks. For example, you’ll learn how to integrate Spring Security-based authentication in web apps written from scratch, so you can leverage existing tooling in your organization without having to take on the entire Spring framework.The first section of the book sets up the base structure of your web app, such as routing, configuration files, and database migrations. The remaining chapters are broken into individual aspects of building production-ready web apps. Appendices at the end of the book explain how to use different libraries than the ones chosen in the main chapters, so you'll learn how to decouple your code from specific libraries, and choose between many different libraries to get the job done in your own web apps.WHAT YOU WILL LEARN* Compose libraries and manage boilerplate code using idiomatic and powerful Kotlin* Manage and query SQL databases without ORMs and mapping layers* Write resilient and change-proof tests in support of test-driven development practices* Create traditional, HTML-based web apps, APIs for JavaScript-based single-page web apps and native mobile apps* Manage parallelism and external service calls using Kotlin co-routines* Deploy to production using embedded servers, WAR files, and serverless approaches* Bridge the gap between custom-built apps and enterprise, using Spring Context and Spring SecurityWHO THIS BOOK IS FORThe expert developer who is ready to take full control of the tech stack, and use the Kotlin language, type system, and standard library, to ship production-ready web apps. Readers should have prior programming experience. Experience with Java or another JVM language is helpful.AUGUST LILLEAAS has built web apps, user interfaces, and real-time systems since 2004, and mobile apps since the app stores opened in the late 2000s. After picking up Clojure in 2012, he left the frameworks and ORMs behind and started to build web apps from scratch, and has shipped to production using Clojure, Groovy, Node.JS, Elixir, and Kotlin. August has worked as a consultant for a decade and is now an independent contractor and startup founder.PART I. UP AND RUNNING WITH A WEB APP1. Setting Up A Development Environment2. Setting Up the Web App Skeleton3. Configuration Files4. Decoupling Web Handlers from Specific LibrariesPART II. LIBRARIES AND SOLUTIONS5. Connecting to and Migrating SQL Databases6. Querying a SQL Database7. Automated Tests with jUnit 58. Parallelizing Service Calls with Coroutines9. Building Traditional Web Apps with HTML and CSS10. Building API Based Backends11. Deploying to Traditional Server Based Environments12. Build and Deploy to a Serverless Environment13. Setup, Teardown and Dependency Injection with Spring Context14. Enterprise Authentication using Spring SecurityPART III. TOOLS OF THE TRADE15. Choosing the Right Library16. An Assortment of Kotlin TricksAppendix A: Using Jooby Instead of KtorAppendix B: Using Hoplite Instead of Typesafe ConfigAppendix C: Using Spek Instead of jUnit 5
Home Appliance Hack-and-IoT Guidebook
If you are looking for a small yet powerful IoT device, you are likely to come across the ESP8266 and compatible products on the market today. One of these, the Wemos/Lolin D1 Mini Pro board strikes a remarkable balance between cost and performance. A small and very aff ordable prototype board, the D1 Mini Pro stands out with its WiFi functionality and a 16-Mbytes flash memory for easy creation of a flash file system. In addition, there are suff icient input and output pins (only one analog input though) to support PWM, I2C, and One-Wire systems to mention but a few. The book describes the operation, modding, construction, and programming of home appliances including a colorful smart home accessory, a refrigerator/greenhouse controller, an AC powerline monitor, a door lock monitor, and an IKEA Trådfri controller.As a benefit, all firmware developed for these DIY, "IoT-ized" devices can be updated over-the-air (OTA).For most of the designs in the book, a small printed circuit board (PCB) and an enclosure are presented so readers can have a finished and attractive-looking product. Readers having – or with access to! – a 3D printer can "print" the suggested enclosures at home or in a shop.Some of the constructions benefit from a Raspberry Pi configured as a gateway or cms server. This is also described in detail with all the necessary configuring.You don't need to be an expert but the prerequisites to successful replication of the projects include basic skills with PC software including the ability to surf the Internet. In terms of hardware, you should be comfortable with soldering and generally assembling the PCBs presented in the book.All custom software written for the IoT devices, the PCB layouts, and 3D print files described in the book are available for free downloading from the books section of Elektor Store website, www.elektor.com/books – simply search for the book title.Hans Henrik Skovgaard has over 25 years of management experience in the mobile phone industry and holds an MSc. in Electronic Engineering. He has authored four top-selling books on electronics design and embedded software.
Modernes C++: Concurrency meistern
Concurrency mit modernem C++ ist eine Reise durch die bestehende und die zukünftige Nebenläufigkeit in C++.Das Buch erklärt Ihnen die Details zu Nebenläufigkeit in modernem C++ und gibt Ihnen mehr als 100 lauffähige Programme. Damit können Sie die Theorie mit der Praxis verknüpfen um den optimalen Nutzen aus dem Buch zu ziehen.Nebenläufigkeit, Parallelität, Gleichzeitigkeit• C++11 und C++14 besitzen die elementaren Bausteine, um nebenläufige und parallele Programme zu schreiben.• Mit C++17 stehen die parallelen Algorithmen der Standard Template Library (STL) vor der Tür. Das heißt, dass die meisten der Algorithmen der STL sequentiell, parallel oder vektorisiert ausgeführt werden können.• Die Geschichte in C++ geht aber weiter. Dank C++20 können wir auf erweiterte Futures, Coroutinen, Transaktionen und noch viel mehr hoffen.Für C++ Entwickler, die ihr Niveau rund um Gleichzeitigkeit auf das nächste Niveau heben wollen. Gleichzeitigkeit ist neben Security und Verteilung eine der Schlüsselherausforderung der Softwareentwicklung der nächsten mindestens 10 Jahre.EXTRA: E-Book inside. Systemvoraussetzungen für E-Book inside: Internet-Verbindung und Adobe-Reader oder Ebook-Reader bzw. Adobe Digital Editions.
Java All-in-One For Dummies
Get started writing Java® code—the easy way Java® code is the go-to language for developing Android apps and all sorts of other things. With Java All-in-One For Dummies, you can write your first lines of code in Java and work your way to advanced stuff like Internet of Things (IoT) programming, JavaFX, and Java for the web. Easy-to-follow instructions, fun practice, and a time-tested instructional approach will shorten your learning journey. With eight mini-books in one, consider this the only Java book you’ll need as your take your knowledge to the next level, and the next, and the next. 8 Mini-books Inside… Java BasicsProgramming BasicsObject-Oriented ProgrammingStrings and Other Data TypesData StructuresAlgorithmsProgramming TechniquesJavaFX A beginning coder’s resource for learning the most popular coding language With Java All-in-One For Dummies, you get 8 books in one, for the most well-rounded Java knowledge on the market. Updated for Java 19, this book includes all the major changes to the programming language, so you won’t fall behind. Start by learning the basics of Java—you can do it, even if you’ve never written a line of code in your life. Then go in-depth, with all the info you need on object-oriented programming, Java FX, Java web development, and beyond. Grab a hot cup of java and settle in to learn some Java, with friendly For Dummies guidance! Learn the basics of computer programming and get started with the Java languageMaster strings, arrays, and collectionsDiscover the most recent Java updates and the latest in programming techniquesLaunch or further your career as a coder with easy-to-follow instruction This is the go-to Dummies guide for future and current coders who need an all-inclusive guide Java to take their knowledge to the next level. Introduction 1 Book 1: Java Basics 5 Chapter 1: Welcome to Java 7 Chapter 2: Installing and Using Java Tools 17 Chapter 3: Working with TextPad 31 Book 2: Programming Basics 37 Chapter 1: Java Programming Basics 39 Chapter 2: Working with Variables and Data Types 59 Chapter 3: Working with Numbers and Expressions 97 Chapter 4: Making Choices 127 Chapter 5: Going Around in Circles (or, Using Loops) 149 Chapter 6: Pulling a Switcheroo 177 Chapter 7: Adding Some Methods to Your Madness 195 Chapter 8: Handling Exceptions 215 Book 3: Object-Oriented Programming 237 Chapter 1: Understanding Object-Oriented Programming 239 Chapter 2: Making Your Own Classes 253 Chapter 3: Working with Statics 273 Chapter 4: Using Subclasses and Inheritance 283 Chapter 5: Using Abstract Classes and Interfaces 305 Chapter 6: Using the Object and Class Classes 327 Chapter 7: Using Inner Classes and Anonymous Classes 355 Chapter 8: Working with Packages and the Java Module System 365 Book 4: Strings and Other Data Types 387 Chapter 1: Working with Strings 389 Chapter 2: Using Regular Expressions 411 Chapter 3: Working with Dates and Times 429 Chapter 4: Using the BigDecimal Class 451 Book 5: Data Structures 471 Chapter 1: Introducing Data Structures 473 Chapter 2: Using Arrays 503 Chapter 3: Using the ArrayList Class 535 Chapter 4: Using the LinkedList Class 549 Chapter 5: Creating Generic Collection Classes 561 Chapter 6: Using Maps and Trees 575 Book 6: Algorithms 595 Chapter 1: Introducing Algorithms 597 Chapter 2: Using Recursion 613 Chapter 3: Sorting 625 Chapter 4: Searching 637 Book 7: Programming Techniques 657 Chapter 1: Programming Threads 659 Chapter 2: Using Functional Programming and Lambda Expressions 689 Chapter 3: Consuming Web Services with HttpClient 705 Book 8: JavaFX 727 Chapter 1: Hello, JavaFX! 729 Chapter 2: Handling Events 751 Chapter 3: Setting the Stage and Scene Layout 769 Chapter 4: Using Layout Panes to Arrange Your Scenes 791 Chapter 5: Getting Input from the User 825 Chapter 6: Choosing from a List 841 Index 869 Doug Lowe is an accomplished technology writer of more than 30 books. He is a tech guru on all things computer programming. His expertise covers networking, Microsoft® Office, programming, and computer building. He is the author of the previous edition of Java All-in-One For Dummies.
Python 3 - Das umfassende Handbuch (7. Auflage)
Das Python-Handbuch zum Lernen und Nachschlagen! Ob Sie erst anfangen, mit Python zu arbeiten oder bei Ihrer Arbeit etwas nachschlagen möchten – in diesem Buch lernen Sie alles, was Sie zu Python 3 wissen müssen. Angefangen mit einer Einführung in die Sprache bietet es eine Sprachreferenz, die Beschreibung der Standardbibliothek und ausführliche Informationen zu professionellen Themen und verschiedenen Anwendungsbereichen. Von der GUI-Programmierung über die Webentwicklung bis zu Data Science: Dieses Buch macht den persönlichen Werkzeugkasten perfekt.Aus dem Inhalt: Sprachgrundlagen und objektorientierte ProgrammierungReguläre AusdrückeDatums- und ZeitfunktionenThread-ProgrammierungGUI-ProgrammierungWebentwicklung mit DjangoMigration von Python 2.x nach 3Mathematische ModuleWissenschaftliches RechnenData ScienceAutoren:Dr. Johannes Ernesti hat am Karlsruher Institut für Technologie (KIT) in angewandter Mathematik promoviert.Dr. Peter Kaiser hat am Karlsruher Institut für Technologie (KIT) in humanoider Robotik promoviert. Seit Mai 2019 arbeitet er als Research Scientist bei DeepL.Leseprobe (PDF-Link)
Java für Dummies (8. Auflg.)
Sie wollen in Java einsteigen oder Ihre Kenntnisse erweitern? »Java für Dummies« ist gleichzeitig Lehrbuch und unverzichtbares Nachschlagewerk für alle Java-Programmierer. Basiswissen zur objektorientierten Programmierung wird genauso vermittelt wie das Prinzip der Wiederverwendbarkeit von Programmbausteinen. Außerdem lernen Sie, wann Variablen innerhalb oder außerhalb von Methoden deklariert werden sollten, wo die Grenzen von Arrays liegen und wie Code mit Exceptions absturzsicher gemacht wird. Diese Auflage von »Java für Dummies« berücksichtigt die Neuerungen der Version Java 17. Barry Burd ist Mathematiker und Professor für Informatik. Er hat alle Auflagen von "Java für Dummies" und "Mit Java programmieren lernen für Dummies" verfasst und schreibt häufig Artikel über Java für Online-Publikationen.Einleitung 23TEIL I: LOS GEHT’S 27Kapitel 1: Alles über Java 29Kapitel 2: Alles über Software 41Kapitel 3: Die grundlegenden Bausteine verwenden 53TEIL II: EIGENE JAVA-PROGRAMME SCHREIBEN 75Kapitel 4: Das Optimum aus Variablen und ihren Werten herausholen 77Kapitel 5: Den Programmablauf mit entscheidungsfindenden Befehlen steuern 115Kapitel 6: Den Programmablauf mit Schleifen steuern 151TEIL III: DAS GROẞE GANZE: OBJEKTORIENTIERTE PROGRAMMIERUNG 169Kapitel 7: Die Sache mit der objektorientierten Programmierung 171Kapitel 8: Zeit und Geld sparen: Code wiederverwenden 211Kapitel 9: Neue Objekte entwerfen 243TEIL IV: INTELLIGENTE JAVA-TECHNIKEN 267Kapitel 10: Variablen und Methoden richtig platzieren 269Kapitel 11: Arrays verwenden, um mit Werten zu jonglieren 301Kapitel 12: Sammlungen und Streams verwenden (wenn Arrays nicht mehr ausreichen) 327Kapitel 13: Gut aussehen, wenn sich die Dinge unerwartet ändern 357Kapitel 14: Namen in Programmteilen gemeinsam nutzen 385Kapitel 15: Referenztypen 411Kapitel 16: Jonglieren mit Java 429Kapitel 17: Datenbankverbindungen aufbauen und nutzen mit Java 449TEIL V: DER TOP-TEN-TEIL 459Kapitel 18: Zehn Ratschläge für neue Softwareentwickler 461Kapitel 19: Zehn Websites für Java 467Abbildungsverzeichnis 469Stichwortverzeichnis 475
R All-in-One For Dummies
A DEEP DIVE INTO THE PROGRAMMING LANGUAGE OF CHOICE FOR STATISTICS AND DATAWith R All-in-One For Dummies, you get five mini-books in one, offering a complete and thorough resource on the R programming language and a road map for making sense of the sea of data we're all swimming in. Maybe you're pursuing a career in data science, maybe you're looking to infuse a little statistics know-how into your existing career, or maybe you're just R-curious. This book has your back. Along with providing an overview of coding in R and how to work with the language, this book delves into the types of projects and applications R programmers tend to tackle the most. You'll find coverage of statistical analysis, machine learning, and data management with R.* Grasp the basics of the R programming language and write your first lines of code* Understand how R programmers use code to analyze data and perform statistical analysis* Use R to create data visualizations and machine learning programs * Work through sample projects to hone your R coding skillThis is an excellent all-in-one resource for beginning coders who'd like to move into the data space by knowing more about R.JOSEPH SCHMULLER is a cognitive scientist and statistical analyst. His recent work in the For Dummies series includes the 5th edition of Statistical Analysis with Excel For Dummies along with Statistical Analysis with R For Dummies and R Projects For Dummies.Introduction 1BOOK 1: INTRODUCING R 5Chapter 1: R: What It Does and How It Does It 7Chapter 2: Working with Packages, Importing, and Exporting 37BOOK 2: DESCRIBING DATA 51Chapter 1: Getting Graphic 53Chapter 2: Finding Your Center 93Chapter 3: Deviating from the Average 103Chapter 4: Meeting Standards and Standings 113Chapter 5: Summarizing It All 125Chapter 6: What’s Normal? 145BOOK 3: ANALYZING DATA 163Chapter 1: The Confidence Game: Estimation 165Chapter 2: One-Sample Hypothesis Testing 181Chapter 3: Two-Sample Hypothesis Testing 207Chapter 4: Testing More than Two Samples 233Chapter 5: More Complicated Testing 257Chapter 6: Regression: Linear, Multiple, and the General Linear Model 279Chapter 7: Correlation: The Rise and Fall of Relationships 315Chapter 8: Curvilinear Regression: When Relationships Get Complicated 335Chapter 9: In Due Time 359Chapter 10: Non-Parametric Statistics 371Chapter 11: Introducing Probability 393Chapter 12: Probability Meets Regression: Logistic Regression 415BOOK 4: LEARNING FROM DATA 423Chapter 1: Tools and Data for Machine Learning Projects 425Chapter 2: Decisions, Decisions, Decisions 449Chapter 3: Into the Forest, Randomly 467Chapter 4: Support Your Local Vector 483Chapter 5: K-Means Clustering 503Chapter 6: Neural Networks 519Chapter 7: Exploring Marketing 537Chapter 8: From the City That Never Sleeps 557BOOK 5: HARNESSING R: SOME PROJECTS TO KEEP YOU BUSY 573Chapter 1: Working with a Browser 575Chapter 2: Dashboards — How Dashing! 603Index 639
Practical Debugging at Scale
Overhaul your debugging techniques and master the theory and tools needed to debug and troubleshoot cloud applications in production environments. This book teaches debugging skills that universities often avoid, but that typically consume as much as 60% of our time as developers. The book covers the use of debugger features such as tracepoints, object marking, watch renderers, and more. Author Shai Almog presents a scientific approach to debugging that is grounded in theory while being practical enough to help you to chase stubborn bugs through the maze of a Kubernetes deployment.Practical Debugging at Scale assumes a polyglot environment as is common for most enterprises, but focuses on JVM environments. Most of the tooling and techniques described are applicable to Python, Node, and other platforms, as well as to Java and other JVM languages. The book specifically covers debugging in production, an often-neglected discipline but an all too painful reality. You’ll learn modern techniques around observability, monitoring, logging, and full stack debugging that you can put to immediate use in troubleshooting common ailments in production environments.YOU WILL LEARN:* The scientific method underlying the process of debugging* Debugger capabilities such as tracepoints and marker objects* The correct use of less understood features such as exception breakpoints* Techniques for tracing issues in production Kubernetes environments* Observability and monitoring to resolve production problems* Industry best practices for common tooling such as logging * Profiling to understand performance and memory problems WHO THIS BOOK IS FORDevelopers in Java and JVM-related languages who want to improve their debugging skills and production reliability; and developers of cloud applications who are facing the pain of production bugs that are hard to replicate and fixSHAI ALMOG is an entrepreneur, open source hacker, speaker, author, blogger, Java rockstar, and more. He is a former Sun (later Oracle) developer with more than 30 years of experience. Shai has built JVMs, development tools, mobile phone environments, banking systems, startup/enterprise backends, user interfaces, development frameworks, and much more. He speaks at conferences all over the world and has shared the stage with luminaries such as James Gosling (father of Java). Shai is an award-winning, highly rated speaker with deep technical experience to share and he has a knack for engaging his audience. IntroductionPART I. BASICS1. Know Your Debugger2. The Checklist3. The Auxiliary Tools4. Logging, Testing, and Fail Fast5. Time Travel DebuggingPART II. THE MODERN PRODUCTION ENVIRONMENT6. Debugging Kubernetes7. Serverless Debugging8. Fullstack Debugging9. Observability and Monitoring10. Developer ObservabilityPART III. IN PRACTICE11. Tools of Learning12. Performance and Memory13. Security14. Bug Strategies
Pro Deep Learning with TensorFlow 2.0
This book builds upon the foundations established in its first edition, with updated chapters and the latest code implementations to bring it up to date with Tensorflow 2.0.Pro Deep Learning with TensorFlow 2.0 begins with the mathematical and core technical foundations of deep learning. Next, you will learn about convolutional neural networks, including new convolutional methods such as dilated convolution, depth-wise separable convolution, and their implementation. You’ll then gain an understanding of natural language processing in advanced network architectures such as transformers and various attention mechanisms relevant to natural language processing and neural networks in general. As you progress through the book, you’ll explore unsupervised learning frameworks that reflect the current state of deep learning methods, such as autoencoders and variational autoencoders. The final chapter covers the advanced topic of generative adversarial networks and their variants, such as cycle consistency GANs and graph neural network techniques such as graph attention networks and GraphSAGE.Upon completing this book, you will understand the mathematical foundations and concepts of deep learning, and be able to use the prototypes demonstrated to build new deep learning applications.WHAT YOU WILL LEARN* Understand full-stack deep learning using TensorFlow 2.0* Gain an understanding of the mathematical foundations of deep learning * Deploy complex deep learning solutions in production using TensorFlow 2.0* Understand generative adversarial networks, graph attention networks, and GraphSAGEWHO THIS BOOK IS FOR:Data scientists and machine learning professionals, software developers, graduate students, and open source enthusiasts.SANTANU PATTANAYAK works as a Senior Staff Machine Learning Specialist at Qualcomm Corp R&D and is the author of Quantum Machine Learning with Python, published by Apress. He has more than 16 years of experience, having worked at GE, Capgemini, and IBM before joining Qualcomm. He graduated with a degree in electrical engineering from Jadavpur University, Kolkata and is an avid math enthusiast. Santanu has a master’s degree in data science from the Indian Institute of Technology (IIT), Hyderabad. He also participates in Kaggle competitions in his spare time, where he ranks in the top 500. Currently, he resides in Bangalore with his wife.Chapter 1: Mathematical FoundationsChapter Goal: Setting the mathematical base for machine learning and deep learning .No of pages 100Sub -Topics1. Linear algebra2. Calculus3. Probability4. Formulation of machine learning algorithms and optimization techniques.Chapter 2: Introduction to Deep learning Concepts and Tensorflow 2.0Chapter Goal: Setting the foundational base for deep learning and introduction to Tensorflow 2.0 programming paradigm.No of pages: 75Sub - Topics:5. Deep learning and its evolution.6. Evolution of the learning techniques: from perceptron based learning to back-propagation7. Different deep learning objectives functions for supervised and unsupervised learning.8. Tensorflow 2.09. GPUChapter 3: Convolutional Neural networksChapter Goal: The mathematical and technical aspects of convolutional neural networkNo of pages: 801. Convolution operation2. Analog and digital signal3. 2D and 3D convolution, dilation and depth-wise separable convolution4. Common image processing filter5. Convolutional neural network and components6. Backpropagation through convolution and pooling layers7. Translational invariance and equivariance8. Batch normalization9. Image segmentation and localization methods (Moved from advanced Neural Network to here, to make room for Graph Neural Networks )Chapter 4: Deep learning for Natural Language ProcessingChapter Goal: Deep learning methods and natural language processing No of pages:Sub - Topics:1. Vector space model2. Word2Vec3. Introduction to recurrent neural network and LSTM4. Attention5. Transformer network architecturesChapter 5: Unsupervised Deep Learning MethodsChapter Goal: Foundations for different unsupervised deep learning techniquesNo of pages: 60Sub - Topics:1. Boltzmann distribution2. Bayesian inference3. Restricted Boltzmann machines4. Auto Encoders and variation methodsChapter 6: Advanced Neural NetworksChapter Goal: Generative adversarial networks and graph neural networksNo of pages: 70Sub - Topics:1. Introduction to generative adversarial networks2. CycleGAN, LSGAN Wasserstein GAN3. Introduction to graph neural network4. Graph attention network and graph SAGEChapter 7: Reinforcement LearningChapter Goal: Reinforcement Learning using Deep LearningNo of pages: 50Sub - Topics:1. Introduction to reinforcement learning and MDP formulation2. Value based methods3. DQN4. Policy based methods5. Reinforce and actor critic network in policy based formulations6. Transition-less reinforcement learning and bandit methods
Internet of Things Using Single Board Computers
Rapidly prototype and program new IoT and Edge solutions using low-cost Maker tech, such as those from Arduino, Raspberry Pi and Nvidia. With a focus on the electronics, this book allows experienced computer science students as well as researchers, practitioners, and even hobbyists to dive right into actual engineering of prototypes and not just theoretical programming and algorithms.You'll learn to interface sensors, work with various communication mediums, incorporate wired and wireless communication protocols, and more with these single board computers. All while working in the popular Python programming language. Additionally, you’ll discover both scripting-based and drag and drop solutions for different problems. As well as a variety of useful, data gathering approaches. Then you can apply what you’ve learned to IoT projects and troubleshooting Industry 4.0 problems.The rapid growth of technology and new development initiatives has made the Internet of Things and Edge analytics an inevitable platform in all engineering domains. The need for sophisticated and ambient environments controlled by tech has resulted in an exponential growth of automation and artificial intelligence. Internet of Things Using Single Board Computers reflects these recent developments while providing a low-cost, easy ramp into the fields of IoT using single board computers and Python programming.WHAT YOU'LL LEARN* Program Arduino, Raspberry Pi, and Nvidia boards for rapid prototyping in IoT and Edge environments* Interface sensors, communication mediums, and wired and wireless communications into your programs and projects.* Study practical applications of these low-cost solutions in fields such as home automation, smart cities, electrical vehicle charging, and more.WHO THIS BOOK IS FOREngineers and hobbyists working on Internet of Things prototypes and applications. Basic skills in electronics and a working knowledge of Python are recommended. Engineers and scientists working on smart environment projects and smart city applications will also benefit.DR. G. R. KANAGACHIDAMBARESAN completed his Ph.D. at Anna University Chennai in 2017. He is currently an Associate Professor in the Department of CSE at Vel Tech Rangarajan Dr. Sagunthala R&D Institute of Science and Technology. His main research interests include Body Sensor Networks and Fault Tolerant Wireless Sensor Networks. He has published several articles and undertaken consultancy activities for leading MNC companies. He has also guest-edited special issue volumes and books and served as an editorial review board member for peer-reviewed journals. He is presently working on several government sponsored research projects like ISRO, DBT, and DST. Presently, he is the Editor in chief for the Next Generation Computer and Communication Engineering series. INTERNET OF THINGS USING SINGLE BOARD COMPUTERSChapter 1: An Overview of IoTChapter 2: IoT ArchitectureChapter 3: Programming Through pythonChapter 4: Wireless Technology for IoTChapter 5: Building IoT with Raspberry PiChapter 6: Home AutomationChapter 7: Smart Cities and Smart GridsChapter 8: Electric Vehicle ChargingChapter 9: Agriculture
Numerical Methods Using Kotlin
This in-depth guide covers a wide range of topics, including chapters on linear algebra, root finding, curve fitting, differentiation and integration, solving differential equations, random numbers and simulation, a whole suite of unconstrained and constrained optimization algorithms, statistics, regression and time series analysis. The mathematical concepts behind the algorithms are clearly explained, with plenty of code examples and illustrations to help even beginners get started.In this book, you'll implement numerical algorithms in Kotlin using NM Dev, an object-oriented and high-performance programming library for applied and industrial mathematics. Discover how Kotlin has many advantages over Java in its speed, and in some cases, ease of use. In this book, you’ll see how it can help you easily create solutions for your complex engineering and data science problems.After reading this book, you'll come away with the knowledge to create your own numerical models and algorithms using the Kotlin programming language.WHAT YOU WILL LEARN* Program in Kotlin using a high-performance numerical library* Learn the mathematics necessary for a wide range of numerical computing algorithms* Convert ideas and equations into code* Put together algorithms and classes to build your own engineering solutions* Build solvers for industrial optimization problems* Perform data analysis using basic and advanced statisticsWHO THIS BOOK IS FORProgrammers, data scientists, and analysts with prior experience programming in any language, especially Kotlin or Java.HAKSUN LI, PHD, is founder of NM Group, a scientific and mathematical research company. He has the vision of “Making the World Better Using Mathematics”. Under his leadership, the firm serves worldwide brokerage houses and funds, multinational corporations and very high net worth individuals. Haksun is an expert in options trading, asset allocation, portfolio optimization and fixed-income product pricing. He has coded up a variety of numerical software, including SuanShu (a library of numerical methods), NM Dev (a library of numerical methods), AlgoQuant (a library for financial analytics), NMRMS (a portfolio management system for equities), and supercurve (a fixed-income options pricing system). Prior to this, Haksun was a quantitative trader/quantitative analyst with multiple investment banks. He has worked in New York, London, Tokyo, and Singapore. Additionally, Haksun is the vice dean of the Big Data Finance and Investment Institute of Fudan University, China. He was an adjunct professor with multiple universities. He has taught at the National University of Singapore (mathematics), Nanyang Technological University (business school), Fudan University (economics), as well as Hong Kong University of Science and Technology (mathematics). Dr. Haksun Li has a B.S. and M.S. in pure and financial mathematics from the University of Chicago, and an M.S. and a PhD in computer science and engineering from the University of Michigan, Ann Arbor.1: Introduction to Numerical Methods in Kotlin.-2: Linear Algebra.-3: Finding Roots of Equations.-4: Finding Roots of Systems of Equations.-5: Curve Fitting and Interpolation.-6: Numerical Differentiation and Integration.-7: Ordinary Differential Equations.-8: Partial Differential Equations.-9: Unconstrained Optimization.-10: Constrained Optimization.-11: Heuristics.-12: Basic Statistics.-13: Random Numbers and Simulation.-14: Linear Regression.-15: Time Series Analysis.-References.Table of ContentsAbout the Authors...........................................................................................................iPreface............................................................................................................................ii1. Why Kotlin?..............................................................................................................61.1. Kotlin in 2022.....................................................................................................61.2. Kotlin vs. C++....................................................................................................61.3. Kotlin vs. Python................................................................................................61.4. Kotlin in the future .............................................................................................62. Data Structures.......................................................................................................72.1. Function...........................................................................................................72.2. Polynomial ......................................................................................................73. Linear Algebra .......................................................................................................83.1. Vector and Matrix ...........................................................................................83.1.1. Vector Properties .....................................................................................83.1.2. Element-wise Operations.........................................................................83.1.3. Norm ........................................................................................................93.1.4. Inner product and angle ...........................................................................93.2. Matrix............................................................................................................103.3. Determinant, Transpose and Inverse.............................................................103.4. Diagonal Matrices and Diagonal of a Matrix................................................103.5. Eigenvalues and Eigenvectors.......................................................................103.5.1. Householder Tridiagonalization and QR Factorization Methods..........103.5.2. Transformation to Hessenberg Form (Nonsymmetric Matrices)...........104. Finding Roots of Single Variable Equations .......................................................114.1. Bracketing Methods ......................................................................................114.1.1. Bisection Method ...................................................................................114.2. Open Methods...............................................................................................114.2.1. Fixed-Point Method ...............................................................................114.2.2. Newton’s Method (Newton-Raphson Method) .....................................114.2.3. Secant Method .......................................................................................114.2.4. Brent’s Method ......................................................................................115. Finding Roots of Systems of Equations...............................................................125.1. Linear Systems of Equations.........................................................................125.2. Gauss Elimination Method............................................................................125.3. LU Factorization Methods ............................................................................125.3.1. Cholesky Factorization ..........................................................................125.4. Iterative Solution of Linear Systems.............................................................125.5. System of Nonlinear Equations.....................................................................126. Curve Fitting and Interpolation............................................................................146.1. Least-Squares Regression .............................................................................146.2. Linear Regression..........................................................................................146.3. Polynomial Regression..................................................................................146.4. Polynomial Interpolation...............................................................................146.5. Spline Interpolation .......................................................................................147. Numerical Differentiation and Integration...........................................................157.1. Numerical Differentiation .............................................................................157.2. Finite-Difference Formulas...........................................................................157.3. Newton-Cotes Formulas................................................................................157.3.1. Rectangular Rule....................................................................................157.3.2. Trapezoidal Rule....................................................................................157.3.3. Simpson’s Rules.....................................................................................157.3.4. Higher-Order Newton-Coles Formulas..................................................157.4. Romberg Integration .....................................................................................157.4.1. Gaussian Quadrature..............................................................................157.4.2. Improper Integrals..................................................................................158. Numerical Solution of Initial-Value Problems....................................................168.1. One-Step Methods.........................................................................................168.2. Euler’s Method..............................................................................................168.3. Runge-Kutta Methods...................................................................................168.4. Systems of Ordinary Differential Equations.................................................169. Numerical Solution of Partial Differential Equations..........................................179.1. Elliptic Partial Differential Equations...........................................................179.1.1. Dirichlet Problem...................................................................................179.2. Parabolic Partial Differential Equations........................................................179.2.1. Finite-Difference Method ......................................................................179.2.2. Crank-Nicolson Method.........................................................................179.3. Hyperbolic Partial Differential Equations.....................................................1710..................................................................................................................................1811..................................................................................................................................1912. Random Numbers and Simulation ....................................................................2012.1. Uniform Distribution .................................................................................2012.2. Normal Distribution...................................................................................2012.3. Exponential Distribution............................................................................2012.4. Poisson Distribution ..................................................................................2012.5. Beta Distribution........................................................................................2012.6. Gamma Distribution ..................................................................................2012.7. Multi-dimension Distribution ....................................................................2013. Unconstrainted Optimization ............................................................................2113.1. Single Variable Optimization ....................................................................2113.2. Multi Variable Optimization .....................................................................2114. Constrained Optimization .................................................................................2214.1. Linear Programming..................................................................................2214.2. Quadratic Programming ............................................................................2214.3. Second Order Conic Programming............................................................2214.4. Sequential Quadratic Programming...........................................................2214.5. Integer Programming.................................................................................2215. Heuristic Optimization......................................................................................2315.1. Genetic Algorithm .....................................................................................2315.2. Simulated Annealing .................................................................................2316. Basic Statistics..................................................................................................2416.1. Mean, Variance and Covariance................................................................2416.2. Moment......................................................................................................2416.3. Rank...........................................................................................................2417. Linear Regression .............................................................................................2517.1. Least-Squares Regression..........................................................................2517.2. General Linear Least Squares....................................................................2518. Time Series Analysis ........................................................................................2618.1. Univariate Time Series..............................................................................2618.2. Multivariate Time Series ...........................................................................2618.3. ARMA .......................................................................................................2618.4. GARCH .....................................................................................................2618.5. Cointegration .............................................................................................2619. Bibliography .....................................................................................................2720. Index .....................................................................................................
Beginning Spring Data
Use the popular Spring Data project for data access and persistence using various Java-based APIs such as JDBC, JPA, MongoDB, and more.This book shows how to easily incorporate data persistence and accessibility into your microservices, cloud-native applications, and monolithic enterprise applications. It also teaches you how to perform unit and performance testing of a component that accesses a database. And it walks you through an example of each type of SQL and NoSQL database covered.After reading this book, you’ll be able to create an application that interacts with one or multiple types of databases, and conduct unit and performance testing to analyze possible problems. Source code is available on GitHub.WHAT YOU’LL LEARN* Become familiar with the Spring Data project and its modules for data access and persistence* Explore various SQL and NoSQL persistence types* Uncover the persistence and domain models, and handle transaction management for SQL* Migrate database changes and versioning for SQL* Dive into NoSQL persistence with Redis, MongoDB, Neo4j, and Cassandra* Handle reactive database programming and access with R2DBC and MongoDB* Conduct unit, integration, and performance testing, and moreWHO THIS BOOK IS FORExperienced Java software application developers; programmers with experience using the Spring framework or the Spring Boot micro frameworkANDRES SACCO is a Technical Lead at Prisma. He has experience using languages such as Java, PHP, and NodeJs. He also has experience using Spring. In his previous job, Andres helped find alternative ways to optimize the transference of data between microservices, which reduced the cost of infrastructure by 55%. He also has written internal courses about new technologies and articles on Medium. Andres shares his knowledge of using different types of databases, depending on the situation. He has experience with various types of testing, to search for problems in queries or repositories that access the database. Part I - IntroductionChapter 1: Architecture of the ApplicationsChapter 2: Spring Basics and BeyondChapter 3: Spring Data and Persistence TypesPart II - SQL PersistenceChapter 4: Persistence and Domain ModelChapter 5: Transaction ManagementChapter 6: Versioning or Migrate the Changes of the DatabasePart III - NO-SQL PersistenceChapter 7: Redis key/value DatabaseChapter 8: MongoDB Document DatabaseChapter 9: Neo4j Graph DatabaseChapter 10: Cassandra wide-column DatabaseChapter 11: Reactive access w/R2DBC and MongoDBChapter 12: Unit/Integration TestingChapter 13: Performance TestingChapter 14: Best PracticesPart I - IntroductionThis part or section contains all the introduction about the basics of the Spring and the architecture of theapplication to use the persistence.Chapter 1: Architecture of the applicationsChapter Goal: In this chapter, the readers will see the different ways of structuring one application and thebest practices to organize all the things related to persistence like the use of DAO (repositories on Spring).• Small history of the methods of persistence (Plain query using the class of Java, ORM)• Different types of architectureso Layerso Hexagonal or onion• Persistence design patterso DAO (Repositories in Spring)o Data Transfer Object (DTO)Chapter 2: Spring basics and beyondChapter Goal: In this chapter, the readers will see the different ways of structuring one application and thebest practices to organize all the things related to persistence like the use of DAO (repositories on Spring).• Spring’s Architecture• Dependency Injection and Inversion of Control• Basic Application SetupChapter 3: Spring Data and different types of persistenceChapter Goal: This chapter will provide a full explanation about Spring Data, how it works and what this librarydoes behind the scenes.• How the Spring Data works• How the Repositories workso Using interfaceso Defining a custom implementationPart II - SQL persistenceThis part or section contains the information about different aspects of the persistence of databases whichhave a rigid schema. Also, the readers will see different strategies of deploying the changes on the schemas.Chapter 4: Persistence and domain modelChapter Goal: In this chapter, the readers will learn the basics about persistence and how it works behind thescenes. Also, the readers will see how to create validations in the schema like the size of the column and thedifferent types of relationship between entities.• JPA configuration using annotationso Entity, Ido Types of relationshipso Pre-update, pre-persist• Ways to define the querieso Using specificationso Define SQL• How validate the schema• Types of InherenceChapter 5: Transaction managementChapter Goal: In this chapter, the readers will learn the basics of the transactions and some concepts of ACID.• Definition of ACID• Isolation Levels• Transactional levelsChapter 6: Versioning or migrate the changes of the databaseChapter Goal: In this chapter the readers will see different tools or strategies to include the changes of thedatabases, e.g use Liquibase/Flyway, running the scripts manually, or using the auto-update of the Spring.Also, this chapter will include some mechanism to move the data from one column to another using featureflags.• Mechanism to migrate the changes• Tools to versioning the changeso Liquibaseo Flyway• Using Feature Flags to new featureso What is a Feature flag?o Benefits of use this approacho Common librariesPart III - NO-SQL persistenceIn this section the idea is to cover one example of each type of the databases NO-SQL like key/value,document, graph, and wide-column database. The idea is not to cover all more than one example of a type ofdatabase because most of them have certain operations similar.Chapter 7: Redis key/value databaseChapter Goal: In this chapter, the readers will see how to run a database and save the information using aspecific key. Also, this chapter will show the readers to create a serializer to persist data that is complex andsome best practices like persist the information in async mode.The last point is how to configure the TTL in the information that the readers persist in the database.• What is Redis and which are the benefits?• Connecting with multiples Redis• Persist synchronous or asynchronous• Object Mapping and ConversionChapter 8: MongoDB Document databaseChapter Goal: In this chapter, the readers will see how to run a mongo database and how to persist theinformation with the definition of the entities using the different operations that are permitted on MongoDB.• What is a document store?• Setting up a Mongo• Access using repositories• Manage transactions in a programmatic wayChapter 9: Neo4j Graph databaseChapter Goal: In this chapter, the readers will see how to run a database and how to create different types ofqueries. Also the reader will see the different aspects of the persistence of the information and the use ofreactive approach.• Modeling the problem as a Grapho Cases of usero Benefits• Persisting the domain• Manage transactionsChapter 10: Cassandra wide-column databaseChapter Goal: In this chapter, the readers will see how to configure the database on Spring and thedeclaration of the entities that need to be used to persist the information. Also, the different ways topersist or modify the information on Cassandra.The last point is how to configure the TTL in the information that the readers persist in the database.• What is Cassandra and how works?• Configuration for Cassandra• Access using repositories• Defining a TTLPart IV – Advanced, testing and best practicesThis part covers some aspects of any type of database to create different types of tests and validate theperformance of the queries. Also, this section covers some best practices to reduce the possible problems ormistakes in the applications that access a database.Chapter 11: Reactive accessChapter Goal: This chapter needs to cover how you can access and obtain the information in a reactive way.• What is reactive access?• Modifying queries to be reactiveo R2DBCo MongoDBChapter 12: Unit/Integration testingChapter Goal: This chapter needs to cover more in detail how you can write unit tests without using anexistent database but using the same motor of the database, to do this the reader will use Test Cointainerswith Junit 5 which is the standard to write unit tests.• Unit Testing with Mocks• Integration Testing with a Databaseo What is Test containers?o Test Containers vs embeddedo How you can use it?o Possible problems in the pipelineChapter 13: Performance testingChapter Goal: In this chapter the reader will use some tools like Gatling or QuickPerform to see how tocreate a performance test and analyze if the queries have some issue related with the use ofCPU/memory.• How check or analyze the performance of the queries?• Analyzing the complexity of queries• Performance test of an endpoint that access to a DBChapter 14: Best practicesChapter Goal: In this chapter the reader will know some strategies to improve the performance of thedatabase including some mechanism of cache to reduce the number of times that anyone accesses toobtain information.• Access to the information◦ Master-slave• Using cache to reduce the accessed to DB• Compress the information• Lazy Loading Issues• Pagination and ways to reduce the response