Software
C++ All-in-One For Dummies
GET READY FOR C++20 WITH ALL YOU NEED TO KNOW FOR COMPLETE MASTERY!Your comprehensive and updated guide to one of the world’s most popular programming languages is here! Whether you’re a novice or expert, you’ll find what you need to get going with the latest features of C++20. The workhorse of programming languages, C++ gives you the utmost control of data usage and interface and resource allocation. If your job involves data, proficiency in C++ means you’re indispensable!This edition gives you 8 books in 1 for total C++ mastery. Inside, internationally renowned expert John Paul Mueller takes you from the fundamentals of working with objects and classes to writing applications that use paradigms not normally associated with C++, such as those used for functional programming strategies. The book also includes online resources such as source code. You discover how to use a C++ GNU compiler to build applications and even how to use your mobile device for coding.* Conquer advanced programming and troubleshooting * Streamline your code with lambda expressions* Use C++ where you need it: for gaming, enterprise applications, and Web services* Uncover object secrets including the use of design patterns * Discover how to use functional programming techniques to make code concise and easy to readIf you want to be your organization’s C++ guru, C++ All-In-One for Dummies is where it’s at!JOHN PAUL MUELLER has produced 116 books and more than 600 articles on a range of topics that include functional programming techniques, application devel- opment using C++, and machine learning methodologies. INTRODUCTION 1About This Book 1Foolish Assumptions 4Icons Used in This Book 4Beyond the Book 5Where to Go from Here 6BOOK 1: GETTING STARTED WITH C++ 7CHAPTER 1: CONFIGURING YOUR DESKTOP SYSTEM 9Obtaining a Copy of C++ 20 10Obtaining Code::Blocks 11Installing Code::Blocks 12Working with Windows 12Working with Mac OS X 13Using the standard Linux installation 14Using the graphical Linux installation 15Touring the Essential Code::Blocks Features 17Starting Code::Blocks for the first time 18Opening the sample projects 19Viewing the essential windows 20Using Other IDEs 25CHAPTER 2: CONFIGURING YOUR MOBILE SYSTEM 27Obtaining CppDroid 28Understanding why CppDroid is such a great choice 29Getting your copy of CppDroid 31Ensuring you get a good install 32Considering Other Alternatives 32Working with C4Droid 33Getting multiple language support with AIDE 33Using web-based IDEs 34Touring the Essential CppDroid Features 35Getting started with CppDroid 35Accessing an example 37Working with a simple online project 37Accessing your source code 38Considering differences with the desktop environment 39Obtaining CppDroid Help 40Working with the Help documentation 40Getting community support 41Using the free examples 42Accessing the tutorials 43CHAPTER 3: CREATING YOUR FIRST C++ APPLICATION 45Code::Blocks Creating a Project 46Understanding projects 46Defining your first project 47Building and executing your first application 52Typing the Code 53Starting with Main 55Showing Information 55Doing some math 60Tabbing your output 66Let Your Application Run Away 67CHAPTER 4: STORING DATA IN C++ 69Putting Your Data Places: Variables 70Creating an integer variable 70Declaring multiple variables 73Changing values 74Setting one variable equal to another 74Initializing a variable 75Creating a great name for yourself 76Manipulating Integer Variables 78Adding integer variables 78Subtracting integer variables 82Multiplying integer variables 84Dividing integer variables 86Characters 88Null character 89Nonprintable and other cool characters 89Strings 93Getting a part of a string 94Changing part of a string 95Adding onto a string 96Adding two strings 97Making Decisions Using Conditional Operators 98Telling the Truth with Boolean Variables 100Reading from the Console 102CHAPTER 5: DIRECTING THE APPLICATION FLOW 105Doing This or Doing That 106Evaluating Conditions in C++ 107Finding the right C++ operators 108Combining multiple evaluations 110Including Evaluations in C++ Conditional Statements 111Deciding what if and also what else 112Going further with the else and if 113Repeating Actions with Statements That Loop 115Understanding how computers use loops 116Looping situations 116Looping for 117Performing a simple for loop 118Using multiple initialization variables 123Working with ranges 126Placing a condition within the declaration 128Letting C++ determine the type 129Looping while 130Doing while 132Breaking and continuing 133Breaking 134Continuing 135Nesting loops 136CHAPTER 6: DIVIDING YOUR WORK WITH FUNCTIONS 139Dividing Your Work 139Calling a Function 144Passing a variable 146Passing multiple variables 147Writing Your Own Functions 148Defining the AddOne() function 149Seeing how AddOne() is called 150Taking the AddOne() Function apart 150Considering the AddOne() parameter 151Understanding the AddOne() name and type 152Improving On the Basic Function 153Using multiple parameters or no parameters 153Returning nothing 156Keeping your variables local 157Forward references and function prototypes 159Writing two versions of the same function 161Calling All String Functions 163Inserting a string into a string 163Removing parts of a string 164Replacing parts of a string 164Using the string functions together 164Understanding main() 165CHAPTER 7: SPLITTING UP SOURCE CODE FILES 169Creating Multiple Source Files 170Adding a new source code file 170Removing an existing source code file 173Creating a project with multiple existing files 173Getting multiple files to interact 177Sharing with Header Files 179Adding the header only once 182Using angle brackets or quotes 182Sharing Variables among Source Files 183Using the Mysterious Header Wrappers 185CHAPTER 8: REFERRING TO YOUR DATA THROUGH POINTERS 187Understanding the Changes in Pointers for C++ 20 188Avoiding broken code 188Considering the issues 189Writing cleaner and less bug-prone code 191Heaping and Stacking the Variables 192Getting a variable’s address 196Changing a variable by using a pointer 198Pointing at a string 200Pointing to something else 203Tips on pointer variables 204Creating New Raw Pointers 205Using new 206Using an initializer 208Freeing Raw Pointers 209Working with Smart Pointers 211Creating smart pointers using std::unique_ptr and std::shared_ptr 212Defining nullable values using std::optional and std::nullopt 216Passing Pointer Variables to Functions 218Returning Pointer Variables from Functions 221PART 2: UNDERSTANDING OBJECTS AND CLASSES 225CHAPTER 1: WORKING WITH CLASSES 227Understanding Objects and Classes 227Classifying classes and objects 230Describing methods and data 231Implementing a class 232Separating method code 237The parts of a class 240Working with a Class 241Accessing members 241Using classes and raw pointers 244Using classes and smart pointers 248Passing objects to functions 249Using const parameters in functions 251Using the this pointer 252Overloading methods 256Starting and Ending with Constructors and Destructors 259Starting with constructors 259Ending with destructors 260Sampling constructors and destructors 260Adding parameters to constructors 263Building Hierarchies of Classes 264Creating a hierarchy in C++ 265Understanding types of inheritance 266Creating and Using Object Aliases 267CHAPTER 2: USING ADVANCED C++ FEATURES 269Filling Your Code with Comments 270Converting Types 272Understanding how int and string conversions work 272Seeing int and string conversions in action 273Considering other conversion issues 276Reading from the Console 277Understanding Preprocessor Directives 282Understanding the basics of preprocessing 282Creating constants and macros with #define 283Performing conditional compilation 286Exercising the basic preprocessor directives 288Using Constants 292Using Switch Statements 295Supercharging enums with Classes 298Working with Random Numbers 300Storing Data in Arrays 302Declaring and accessing an array 303Arrays of pointers 304Passing arrays to functions 306Adding and subtracting pointers 307CHAPTER 3: PLANNING AND BUILDING OBJECTS 309Recognizing Objects 310Observing the Mailboxes class 312Observing the Mailbox class 314Finding other objects 315Encapsulating Objects 316Considering the Application Programming Interface 316Understanding properties 316Choosing between private and protected 318Defining a process 318Implementing properties 319Building Hierarchies 322Establishing a hierarchy 322Protecting members when inheriting 324Overriding methods 330Specializing with polymorphism 332Getting abstract about things 333CHAPTER 4: BUILDING WITH DESIGN PATTERNS 335Delving Into Pattern History 336Introducing a Simple Pattern: the Singleton 337Using an existing pattern 337Creating a singleton pattern class 338Watching an Instance with an Observer 341Understanding the observer pattern 341Defining an observer pattern class 343Observers and the Standard C++ Library 346Automatically adding an observer 347Mediating with a Pattern 349Defining the mediator pattern scenario 350Outlining the car example 351Creating the car example 354BOOK 3: UNDERSTANDING FUNCTIONAL PROGRAMMING 367CHAPTER 1: CONSIDERING FUNCTIONAL PROGRAMMING 369Understanding How Functional Programming Differs 370Defining an Impure Language 373Considering the requirements 373Understanding the C++ functional limitations 374Seeing Data as Immutable 375Working with immutable variables 376Working with immutability in classes and structures 377Creating constant expressions 378Considering the Effects of State 381Eliminating Side Effects 382Contrasting declarations and functions 383Associating functions with side effects 384Removing side effects 385Creating a declarative C++ example 387Understanding the Role of auto 388Passing Functions to Functions 390Seeing a simple example of function input 391Using transforms 393Using Lambda Expressions for Implementation 394CHAPTER 2: WORKING WITH LAMBDA EXPRESSIONS 397Creating More Readable and Concise C++ Code 398Defining the Essential Lambda Expression 399Defining the parts of a lambda expression 399Relying on computer detection of return type 401Using the auto keyword with lambda expressions 404Using lambda expressions as macros 405Developing with Lambda Expressions 406Using lambda expressions with classes and structures 407Working with the capture clause 408Sorting data using a lambda expression 411Specifying that the lambda expression throws exceptions 413CHAPTER 3: ADVANCED LAMBDA EXPRESSIONS 415Considering the C++ 20 Lambda Extensions 416Defining an immediate function 416Using = and this in captures 417Finding other changes 418Working in Unevaluated Contexts 418Using Assignable Stateless Lambda Expressions 420Dealing with Pack Expansions 422Considering the template 422Processing the variables using recursion 423Processing the variables using a lambda expression 424BOOK 4: FIXING PROBLEMS 427CHAPTER 1: DEALING WITH BUGS 429It’s Not a Bug It’s a Feature! 430Make Your Application Features Look Like Features 431Anticipating (Almost) Everything 432Considering menus 432Dealing with textual input 435Performing string processing 437Avoiding Mistakes, Plain and Simple 441CHAPTER 2: DEBUGGING AN APPLICATION 443Programming with Debuggers 444Running the debugger 446Recognizing the parts of the Code::Blocks debugger 453Debugging with Different Tools 455Debugging a Code::Blocks Application with Command-Line Arguments 456CHAPTER 3: STOPPING AND INSPECTING YOUR CODE 457Setting and Disabling Breakpoints 458Setting a breakpoint in Code::Blocks 459Enabling and disabling breakpoints 460Watching, Inspecting, and Changing Variables 463Watching the variables 465Changing values 466CHAPTER 4: TRAVELING ABOUT THE STACK 469Stacking Your Data 470Moving about the stack 471Storing local variables 473Debugging with Advanced Features 475Viewing threads 475Tracing through assembly code 475BOOK 5: ADVANCED PROGRAMMING 479CHAPTER 1: WORKING WITH ARRAYS, POINTERS, AND REFERENCES 481Building Up Arrays 482Declaring arrays 482Arrays and pointers 484Using multidimensional arrays 488Arrays and command-line parameters 492Allocating an array on the heap 494Deleting an array from the heap 494Storing arrays of pointers and arrays of arrays 495Building constant arrays 498Pointing with Pointers 498Becoming horribly complex 499Pointers to functions 505Pointing a variable to a method 506Pointing to static methods 509Referring to References 510Reference variables 510Returning a reference from a function 511CHAPTER 2: CREATING DATA STRUCTURES 515Working with Data 515The great variable roundup 516Expressing variables from either side 518Casting a spell on your data 520Comparing casting and converting 521Casting safely with C++ 523Structuring Your Data 529Structures as component data types 531Equating structures 531Returning compound data types 532Naming Your Space 534Creating a namespace 534Employing using namespace 535Using variables 537Using part of a namespace 538CHAPTER 3: CONSTRUCTORS, DESTRUCTORS, AND EXCEPTIONS 541Constructing and Destructing Objects 542Overloading constructors 542Initializing members 543Adding a default constructor 548Functional constructors 550Calling one constructor from another 553Copying instances with copy constructors 555When constructors go bad 557Destroying your instances 558Virtually inheriting destructors 560Programming the Exceptions to the Rule 563Creating a basic try catch block 563Using multiple catch blocks 565Throwing direct instances 566Catching any exception 567Rethrowing an exception 568Using a standard category 570CHAPTER 4: ADVANCED CLASS USAGE 571Inherently Inheriting Correctly 572Morphing your inheritance 572Avoiding polymorphism 573Adjusting access 574Avoiding variable naming conflicts 575Using class-based access adjustment 576Returning something different, virtually speaking 577Multiple inheritance 581Virtual inheritance 584Friend classes and functions 588Using Classes and Types within Classes 591Nesting a class 591Types within classes 597CHAPTER 5: CREATING CLASSES WITH TEMPLATES 601Templatizing a Class 602Considering types 602Defining the need for templates 602Creating and using a template 605Understanding the template keyword 607Going Beyond the Basics 609Separating a template from the function code 609Including static members in a template 611Parameterizing a Template 612Putting different types in the parameter 613Including multiple parameters 616Working with non-type parameters 619Typedefing a Template 622Deriving Templates 623Deriving classes from a class template 623Deriving a class template from a class 626Deriving a class template from a class template 627Templatizing a Function 630Overloading and function templates 632Templatizing a method 635CHAPTER 6: PROGRAMMING WITH THE STANDARD LIBRARY 637Architecting the Standard Library 638Containing Your Classes 638Storing in a vector 639Working with std::array 642Mapping your data 643Containing instances, pointers, or references 644Working with copies 648Comparing instances 649Iterating through a container 655A map of pairs in your hand 658The Great Container Showdown 658Associating and storing with a set 658Unionizing and intersecting sets 662Listing with list 664Stacking the deque 669Waiting in line with stacks and queues 670Copying Containers 673Creating and Using Dynamic Arrays 675Working with Unordered Data 677Using std::unordered_set to create an unordered set 677Manipulating unordered sets 677Working with Ranges 679BOOK 6: READING AND WRITING FILES 681CHAPTER 1: FILING INFORMATION WITH THE STREAMS LIBRARY 683Seeing a Need for Streams 684Programming with the Streams Library 686Getting the right header file 686Opening a file 687Reading from a file 690Reading and writing a file 691Working with containers 692Handling Errors When Opening a File 693Flagging the ios Flags 695CHAPTER 2: WRITING WITH OUTPUT STREAMS 697Inserting with the
Programming Kotlin Applications
LEARN TO PROGRAM WITH KOTLIN, ONE OF THE FASTEST-GROWING PROGRAMMING LANGUAGES AVAILABLE TODAYProgramming Kotlin Applications: Building Mobile and Server-Side Applications with Kotlin drops readers into the fast lane for learning to develop with the Kotlin programming language. Authored by accomplished cloud consultant and technology professional Brett McLaughlin, Programming Kotlin Applications provides readers with the pragmatic and practical advice they need to build their very first Kotlin applications.Designed to give readers a thorough understanding of Kotlin that goes beyond mere mobile programming, this book will help you:* Learn how to develop your first Kotlin project* Understand how Kotlin securely protects and stores information* Advocate for using Kotlin in your own professional and personal environments* Understand Kotlin's goals and how to use it as its best* Know when to avoid using KotlinProgramming Kotlin Applications is written in a highly approachable and accessible way without the fluff and unrealistic samples that characterize some of its competitor guides. Perfect for developers familiar with another object-oriented programming language like Java or Ruby, or for people who want to advance their skillset in the Kotlin environment, this book is an indispensable addition to any programmer’s library.About the author BRETT MCLAUGHLIN has over two decades of experience working and writing in technology. He focuses on cloud and enterprise computing and has become a recognized and trusted name in helping organizations migrate to the cloud, especially with Amazon Web Services. He has led large-scale cloud migrations for NASA's Earth Science program as well as the RockCreek Group's financial platform. He is a sought-after speaker, author, and educator. Visit us at wrox.com for free code samples. Introduction xxvCHAPTER 1: OBJECTS ALL THE WAY DOWN 1Kotlin: A New Programming Language 1What is Kotlin? 2What Does Kotlin Add to Java? 3Kotlin is Object-Oriented 3Interlude: Set Up Your Kotlin Environment 4Install Kotlin (and an IDE) 4Install IntelliJ 5Create Your Kotlin Program 8Compile and Run Your Kotlin Program 9Fix Any Errors as They Appear 10Install Kotlin (and Use the Command Line) 10Command-Line Kotlin on Windows 10Command-Line Kotlin on Mac OS X 11Command-Line Kotlin on UNIX-Based Systems 12Verify Your Command-Line Installation 12Creating Useful Objects 13Pass In Values to an Object Using Its Constructor 13Print an Object with toString() 14Terminology Update: Functions and Methods 15Print an Object (and Do It with Shorthand) 15Override the toString() Method 16All Data is Not a Property Value 17Initialize an Object and Change a Variable 19Initialize a Class with a Block 19Kotlin Auto-Generates Getters and Setters 20Terminology Update: Getters, Setters, Mutators, Accessors 20Constants Can’t Change (Sort of) 21CHAPTER 2: IT’S HARD TO BREAK KOTLIN 25Upgrade Your Kotlin Class Game 25Name a File According to Its Class 26Organize Your Classes with Packages 27Put Person in a Package 28Classes: The Ultimate Type in Kotlin 31Kotlin Has a Large Number of Types 31Numbers in Kotlin 31Letters and Things 32Truth or Fiction 33Types Aren’t Interchangeable (Part 1) 33You Must Initialize Your Properties 34Types Aren’t Interchangeable (Part 2) 35You Can Explicitly Tell Kotlin What Type to Use 36Try to Anticipate How Types Will Be Used 37It’s Easy to Break Kotlin (Sort of) 37Overriding Property Accessors and Mutators 37Custom-Set Properties Can’t Be in a Primary Constructor 38Move Properties Out of Your Primary Constructors 38Initialize Properties Immediately 39Try to Avoid Overusing Names 41Override Mutators for Certain Properties 41Classes Can Have Custom Behavior 43Define a Custom Method on Your Class 43Every Property Must Be Initialized 44Assign an Uninitialized Property a Dummy Value 45Tell Kotlin You’ll Initialize a Property Later 45Assign Your Property the Return Value from a Function 46Sometimes You Don’t Need a Property! 47TYPE SAFETY CHANGES EVERYTHING 49Writing Code is Rarely Linear 49CHAPTER 3: KOTLIN IS EXTREMELY CLASSY 51Objects, Classes, and Kotlin 51All Classes Need an equals(x) Method 52Equals(x) is Used to Compare Two Objects 52Override equals(x) to Make It Meaningful 54Every Object is a Particular Type 56A Brief Introduction to Null 58Every Object Instance Needs a Unique hashCode() 59All Classes Inherit from Any 59Always Override hashCode() and equals(x) 61Default Hash Codes Are Based on Memory Location 63Use Hash Codes to Come Up with Hash Codes 63Searching (and Other Things) Depend on Useful and Fast equals(x) and hashCode() 64Multiple Properties to Differentiate Them in hashCode() 65Use == over equals(x) for Speed 66A Quick Speed Check on hashCode() 66Basic Class Methods Are Really Important 67CHAPTER 4: INHERITANCE MATTERS 69Good Classes Are Not Always Complex Classes 69Keep It Simple, Stupid 70Keep It Flexible, Stupid 71Classes Can Define Default Values for Properties 73Constructors Can Accept Default Values 74Kotlin Expects Arguments in Order 74Specify Arguments by Name 74Change the Order of Arguments (If You Need) 75Secondary Constructors Provide Additional Construction Options 76Secondary Constructors Come Second 76Secondary Constructors Can Assign Property Values 77You Can Assign null to a Property . . . Sometimes 79null Properties Can Cause Problems 81Handle Dependent Values with Custom Mutators 82Set Dependent Values in a Custom Mutator 82All Property Assignments Use the Property’s Mutator 83Nullable Values Can Be Set to null! 84Limit Access to Dependent Values 86When Possible, Calculate Dependent Values 87You Can Avoid Parentheses with a Read-Only Property 88Need Specifics? Consider a Subclass 91Any is the Base Class for Everything in Kotlin 91{ . . . } Is Shorthand for Collapsed Code 93A Class Must Be Open for Subclassing 94Terminology: Subclass, Inherit, Base Class, and More 95A Subclass Must Follow Its Superclass’s Rules 96A Subclass Gets Behavior from All of Its Superclasses 96Your Subclass Should Be Different Than Your Superclass 97Subclass Constructors Often Add Arguments 97Don’t Make Mutable What Isn’t Mutable 98Sometimes Objects Don’t Exactly Map to the Real World 99Generally, Objects Should Map to the Real World 99CHAPTER 5: LISTS AND SETS AND MAPS, OH MY! 101Lists Are Just a Collection of Things 101Kotlin Lists: One Type of Collection 101Collection is a Factory for Collection Objects 102Collection is Automatically Available to Your Code 104Mutating a Mutable List 105Getting Properties from a Mutable List 105Lists (and Collections) Can Be Typed 106Give Your Lists Types 107Iterate over Your Lists 108Kotlin Tries to Figure Out What You Mean 111Lists Are Ordered and Can Repeat 111Order Gives You Ordered Access 112Lists Can Contain Duplicate Items 112Sets: Unordered but Unique 113In Sets, Ordering is Not Guaranteed 114When Does Order Matter? 115Sort Lists (and Sets) on the Fly 115Sets: No Duplicates, No Matter What 116Sets “Swallow Up” Duplicates 116Sets Use equals(x) to Determine Existing Membership 116Using a Set? Check equals(x) 119Iterators Aren’t (Always) Mutable 119Maps: When a Single Value Isn’t Enough 119Maps Are Created by Factories 120Use Keys to Find Values 120How Do You Want Your Value? 121Filter a Collection by . . . Anything 121Filter Based on a Certain Criterion 122Filter Has a Number of Useful Variations 123Collections: For Primitive and Custom Types 123Add a Collection to Person 124Allow Collections to Be Added to Collection Properties 126Sets and MutableSets Aren’t the Same 127Collection Properties Are Just Collections 128CHAPTER 6: THE FUTURE (IN KOTLIN) IS GENERIC 129Generics Allow Deferring of a Type 129Collections Are Generic 129Parameterized Types Are Available Throughout a Class 130Generic: What Exactly Does It Refer To? 131Generics Try to Infer a Type When Possible 132Kotlin Looks for Matching Types 132Kotlin Looks for the Narrowest Type 132Sometimes Type Inference is Wrong 133Don’t Assume You Know Object Intent 133Kotlin Doesn’t Tell You the Generic Type 134Just Tell Kotlin What You Want! 134Covariance: A Study in Types and Assignment 134What about Generic Types? 135Some Languages Take Extra Work to Be Covariant 137Kotlin Actually Takes Extra Work to Be Covariant, Too 137Sometimes You Have to Make Explicit What is Obvious 137Covariant Types Limit the Input Type as Well as the Output Type 137Covariance is Really about Making Inheritance Work the Way You Expect 138Contravariance: Building Consumers from Generic Types 138Contravariance: Limiting What Comes Out Rather Than What Comes In 139Contravariance Works from a Base Class Down to a Subclass 141Contravariant Classes Can’t Return a Generic Type 141Does Any of This Really Matter? 142Unsafevariance: Learning The Rules, then Breaking Them 142Typeprojection Lets You Deal with Base Classes 143Variance Can Affect Functions, Not Just Classes 143Type Projection Tells Kotlin to Allow Subclasses as Input for a Base Class 144Producers Can’t Consume and Consumers Can’t Produce 145Variance Can’t Solve Every Problem 145CHAPTER 7: FLYING THROUGH CONTROL STRUCTURES 147Control Structures Are the Bread and Butter of Programming 147If and Else: The Great Decision Point 148!! Ensures Non-Nullable Values 148Control Structures Affect the Flow of Your Code 149if and else Follow a Basic Structure 150Expressions and if Statements 151Use the Results of an if Statement Directly 152Kotlin Has No Ternary Operator 153A Block Evaluates to the Last Statement in That Block 153if Statements That Are Assigned Must Have else Blocks 154When is Kotlin’s Version of Switch 154Each Comparison or Condition is a Code Block 155Handle Everything Else with an else Block 156Each Branch Can Support a Range 157Each Branch Usually Has a Partial Expression 158Branch Conditions Are Checked Sequentially 159Branch Conditions Are Just Expressions 159When Can Be Evaluated as a Statement, Too 160For is for Looping 161For in Kotlin Requires an Iterator 162You Do Less, Kotlin Does More 163For Has Requirements for Iteration 163You Can Grab Indices Instead of Objects with for 164Use While to Execute until a Condition is False 167While is All about a Boolean Condition 167A Wrinkle in while: Multiple Operators, One Variable 168Combine Control Structures for More Interesting Solutions 169Do . . . While Always Runs Once 170Every do . . . while Loop Can Be Written as a while Loop 170If Something Must Happen, Use do . . . while 171do . . . while Can Be a Performance Consideration 175Get Out of a Loop Immediately with Break 176Break Skips What’s Left in a Loop 176You Can Use a Label with break 177Go to the Next Iteration Immediately with Continue 178Continue Works with Labels as Well 179If versus continue: Mostly Style over Substance 179Return Returns 180CHAPTER 8: DATA CLASSES 183Classes in the Real World Are Varied but Well Explored 183Many Classes Share Common Characteristics 183Common Characteristics Result in Common Usage 185A Data Class Takes the Work Out of a Class Focused on Data 185Data Classes Handle the Basics of Data for You 185The Basics of Data Includes hashCode() and equals(x) 186Destructuring Data through Declarations 188Grab the Property Values from a Class Instance 188Destructuring Declarations Aren’t Particularly Clever 189Kotlin is Using componentN() Methods to Make Declarations Work 190You Can Add componentN() Methods to Any Class 191If You Can Use a Data Class, You Should 192You Can “Copy” an Object or Make a Copy Of an Object 192Using = Doesn’t Actually Make a Copy 192If You Want a Real Copy, Use copy() 193Data Classes Require Several Things from You 194Data Classes Require Parameters and val or var 194Data Classes Cannot Be Abstract, Open, Sealed, or Inner 195Data Classes Add Special Behavior to Generated Code 195You Can Override Compiler-Generated Versions of Many Standard Methods 196Supertype Class Functions Take Precedence 196Data Classes Only Generate Code for Constructor Parameters 197Only Constructor Parameters Are Used in equals() 199Data Classes Are Best Left Alone 200CHAPTER 9: ENUMS AND SEALED, MORE SPECIALTY CLASSES 203Strings Are Terrible as Static Type Representations 203Strings Are Terrible Type Representations 204Capitalization Creates Comparison Problems 205This Problem Occurs All the Time 206String Constants Can Help . . . Some 206Companion Objects Are Single Instance 207Constants Must Be Singular 208Companion Objects Are Singletons 209Companion Objects Are Still Objects 210You Can Use Companion Objects without Their Names 211Using a Companion Object’s Name is Optional 211Using a Companion Object’s Name is Stylistic 213Companion Object Names Are Hard 214You Can Skip the Companion Object Name Altogether 215Enums Define Constants and Provide Type Safety 216Enums Classes Provide Type-Safe Values 216Enums Classes Are Still Classes 218Enums Give You the Name and Position of Constants 219Each Constant in an enum is an Object 219Each Constant Can Override Class-Level Behavior 220Sealed Classes Are Type-Safe Class Hierarchies 221Enums and Class Hierarchies Work for Shared Behavior 222Sealed Classes Address Fixed Options and Non-Shared Behavior 222Sealed Classes Don’t Have Shared Behavior 223Sealed Classes Have a Fixed Number of Subclasses 224Subclasses of a Sealed Class Don’t Always Define Behavior 225when Requires All Sealed Subclasses to Be Handled 225when Expressions Must Be Exhaustive for Sealed Classes 226else Clauses Usually Don’t Work for Sealed Classes 228else Clauses Hide Unimplemented Subclass Behavior 229CHAPTER 10: FUNCTIONS AND FUNCTIONS AND FUNCTIONS 233Revisiting the Syntax of a Function 233Functions Follow a Basic Formula 233Function Arguments Also Have a Pattern 235Default Values in Constructors Are Inherited 237Default Values in Functions Are Inherited 238Default Values in Functions Cannot Be Overridden 239Default Values Can Affect Calling Functions 239Calling Functions Using Named Arguments is Flexible 241Function Arguments Can’t Be Null Unless You Say So 241Functions Follow Flexible Rules 243Functions Actually Return Unit by Default 243Functions Can Be Single Expressions 244Single-Expression Functions Don’t Have Curly Braces 245Single-Expression Functions Don’t Use the return Keyword 246Single-Expression Functions Can Infer a Return Type 246Type Widening Results in the Widest Type Being Returned 248Functions Can Take Variable Numbers of Arguments 249A vararg Argument Can Be Treated Like an Array 251Functions in Kotlin have Scope 251Local Functions Are Functions Inside Functions 252Member Functions Are Defined in a Class 252Extension Functions Extend Existing Behavior without Inheritance 253Extend an Existing Closed Class Using Dot Notation 253this Gives You Access to the Extension Class 255Function Literals: Lambdas and Anonymous Functions 257Anonymous Functions Don’t Have Names 257You Can Assign a Function to a Variable 258Executable Code Makes for an “Executable” Variable 259Higher-Order Functions Accept Functions as Arguments 260The Result of a Function is Not a Function 260Function Notation Focuses on Input and Output 261You Can Define a Function Inline 263Lambda Expressions Are Functions with Less Syntax 264You Can Omit Parameters Altogether 266Lambda Expressions Use it for Single Parameters 266It Makes Lambdas Work More Smoothly 267Lambda Expressions Return the Last Execution Result 267Trailing Functions as Arguments to Other Functions 268Lots of Functions, Lots of Room for Problems 268CHAPTER 11: SPEAKING IDIOMATIC KOTLIN 271Scope Functions Provide Context to Code 271Use Let to Provide Immediate Access to an Instance 272let Gives You it to Access an Instance 273The Scoped Code Blocks Are Actually Lambdas 274let and Other Scope functions Are Largely about Convenience 275You Can Chain Scoped Function Calls 275An Outer it “Hides” an Inner it 276Chaining Scope Functions and Nesting Scope Functions Are Not the Same 277Nesting Scope Functions Requires Care in Naming 277Chaining Scope Functions is Simpler and Cleaner 278Prefer Chaining over Nesting 279Many Chained Functions Start with a Nested Function 280You Can Scope Functions to Non-Null Results 280Accepting null Values Isn’t a Great Idea 282Scope Functions Give You Null Options 282Scope Functions Work on Other Functions . . . In Very Particular Ways 284With is a Scope Function for Processing an Instance 287with Uses this as Its Object Reference 287A this Reference is Always Available 288with Returns the Result of the Lambda 289Run is a Code Runner and Scope Function 289Choosing a Scope Function is a Matter of Style and Preference 290run Doesn’t Have to Operate on an Object Instance 291Apply Has a Context Object but No Return Value 292apply Operates Upon an Instance 292apply Returns the Context Object, Not the Lambda Result 293?: is Kotlin’s Elvis Operator 293Also Gives You an Instance . . . but Operates on the Instance First 294also is Just Another Scope Function 295also Executes before Assignment 296Scope Functions Summary 298CHAPTER 12: INHERITANCE, ONE MORE TIME, WITH FEELING 303Abstract Classes Require a Later Implementation 303Abstract Classes Cannot Be Instantiated 304Abstract Classes Define a Contract with Subclasses 306Abstract Classes Can Define Concrete Properties and Functions 308Subclasses Fulfill the Contract Written by an Abstract Class 310Subclasses Should Vary Behavior 310The Contract Allows for Uniform Treatment of Subclasses 311Interfaces Define Behavior but Have No Body 313Interfaces and Abstract Classes Are Similar 315Interfaces Cannot Maintain State 316A Class’s State is the Values of Its Properties 317An Interface Can Have Fixed Values 317Interfaces Can Define Function Bodies 318Interfaces Allow Multiple Forms of Implementation 319A Class Can Implement Multiple Interfaces 320Interface Property Names Can Get Confusing 321Interfaces Can Decorate a Class 321Delegation Offers Another Option for Extending Behavior 322Abstract Classes Move from Generic to Specific 322More Specificity Means More Inheritance 324Delegating to a Property 326Delegation Occurs at Instantiation 329Inheritance Requires Forethought and Afterthought 330CHAPTER 13: KOTLIN: THE NEXT STEP 331Programming Kotlin for Android 331Kotlin for Android is Still Just Kotlin 331Move from Concept to Example 333Kotlin and Java Are Great Companions 333Your IDE is a Key Component 333Kotlin is Compiled to Bytecode for the Java Virtual Machine 335Gradle Gives You Project Build Capabilities 335When Kotlin Questions Still Exist 335Use the Internet to Supplement Your Own Needs and Learning Style 336Now What? 337Index 339
Modern PyQt
Dive into GUI application development and create useful applications for practical and relevant topics in the fields of business, computer science, and research. This book uses a realistic approach to help get you started designing and building the applications you need while learning new tools along the way.PyQt has a vast collection of tools that you can use to create GUIs, many of which seem to go unexplored. In Modern PyQt, you will go beyond some of the fundamental topics of GUI development in order to begin building useful desktop applications. Through extensive examples and hands-on projects, you will explore how to make applications for data analysis and visualization using graphs, computer vision with OpenCV and PyQt, the basics of networking, handling databases with SQL, and more!Whether you are looking for new ideas to practice your skills as a programmer or you have a specific goal in mind and need some help to get your ideas off the ground, there is something in Modern PyQt for you!WHAT YOU WILL LEARN* Create cross-platform GUIs with Python and PyQt.* Understand the important PyQt classes, widgets, and concepts needed for building interactive and practical applications. * Find out how to embed useful Python modules into your applications to create more advanced GUIs. * Build useful applications that you can improve or make into something completely new with Python and PyQt.WHO THIS BOOK IS FORIntermediate level programmers or above in Python. GUI developers with some experience designing GUIs. Even if they have never used PyQt before, the concepts learned from other toolkits, such as Tkinter or wxPython, can be carried over for developing applications with using PyQt.Joshua Willman began using Python in 2015 when he needed to build neural networks using machine learning libraries for image classification. While building large image data sets for his research, he needed to build a GUI that would simplify the workload and labeling process, which introduced him to PyQt. Since then, he has tried to dive into everything that is Python. He currently works as a Python developer, building projects to help others learn more about coding in Python for game development, AI and machine learning, and programming using micro-controllers. More recently, he set up the site redhuli.io to explore his and others’ interests in utilizing programming for creativity.He is also the author of Beginning PyQt: A Hands-on Approach to GUI Programming.
Home Server
Das eigene Netzwerk mit Intel NUC oder Raspberry Pi - so richten Sie Ihren Heimserver ein.Mit einer eigenen Schaltzentrale in Ihrem Heimnetzwerk sorgen Sie dafür, dass Sie zuverlässig alle Ihre Daten und Dienste jederzeit im Zugriff haben. Wie Sie einen solchen Home Server einfach und günstig mit dem Raspberry Pi oder dem Intel NUC einrichten, zeigt Ihnen Dennis Rühmer in seinem neuen Leitfaden. Auf 800 Seiten lernen Sie alles, was Sie brauchen, mit vielen Anleitungen und Hinweisen zu Sicherheit und Telefonie. Ob Sie auf Ihre eigene Cloud von überall zugreifen wollen, ob Sie einen privaten Chat-Dienst einrichten möchten, Musik und Videos im eigenen Netzwerk gestreamt werden sollen, oder ob Sie einen zuverlässigen VPN-Server brauchen: Sie werden überrascht sein, wie Sie mit ein wenig Hardware und dem Wissen aus diesem Buch ein leistungsstarkes System zu Hause aufbauen können.Leseprobe (PDF-Link)
Machine Learning für Zeitreihen
Einstieg in Regressions-, ARIMA- und Deep Learning-Verfahren mit Python.Daten über Vorgänge werden in der verarbeitenden Industrie, der Logistik oder im Finanzsektor im Sekundentakt aufgezeichnet: der Verlauf eines Aktienkurses, die Verkaufszahlen eines Produkts, die Sensordaten einer Turbine. Solche Daten informieren nicht nur über isolierte Zustände; sie sind wie Filme, die den Verlauf eines Vorgangs mit einer Serie einzelner Bilder nachzeichnen. Intelligente Algorithmen können die Muster dieser Verläufe analysieren, sie anlernen und über das Beobachtungsfenster hinaus fortschreiben: Zustände in der Zukunft werden prognostizierbar.Das Buch bietet eine leicht verständliche Einführung in die Konzepte und die Praxis der Zeitreihenanalyse. Es zeigt, wie bewährte und neuere Lernalgorithmen arbeiten und wie sie sich mit Python anlernen und produktiv einsetzen lassen.An einer Vielzahl von Anwendungsbeispielen werden die Vorbereitung der Daten, der Anlern- und Schätzprozess Schritt für Schritt erklärt.Aus dem Inhalt:- Zeitreihendaten mit pandas aufbereiten, fehlende Daten imputieren, mit Datumsangaben arbeiten- Grundprinzipien maschinellen Lernens: Konzepte und Umsetzung mit Python und Scikit-Learn- Feature-Preprocessing: Standardisierung, Dimensionsreduktion, Verarbeitung kategorialer Daten- ARIMA-Modelle zur Analyse univariater Zeitreihen: Vorbereitung, Anlernen und Prognose mit Python und Statsmodels- Komplexe Zeitreihen mit Deep-Learning-Verfahren analysieren: Rekurrente und konvolutionale Netze verstehen und mit Python und TensorFlow 2 aufbauen und anlernen- Mit Zeifenstern arbeitenVorkenntnisse in Machine-Learning-Verfahren sind nicht notwendig. Grundlegende Statistik- und Python-Kenntnisse sollten vorhanden sein.Der komplette Code im Buch sowie die Beispieldateien sind über ein GitHub-Repository verfügbar.
Android-Apps entwickeln mit Java (9. Auflg.)
Aktuell zu Android Studio 4 - ihr Einstieg in die Android-Programmierung in 9. Auflage 2020.Ihr Einstieg in die App-Entwicklung mit Android Studio. Hier lernen Sie auf besonders einfache und unterhaltsame Weise, wie Sie mit Java für Android-Geräte entwickeln – z. B. ein eigenes Spiel mit allem Drum und Dran. Für Ihre App setzen Sie Animationen, Sounds, Bewegungssensoren und die Kamera ein und erstellen schicke Layouts, Online-Bestenlisten und angesagte Features für die Smartwatch. Alles ganz aktuell zu Android Studio 4. Grundkenntnisse in der Programmierung sollten Sie mitbringen, Ihr Java-Wissen frischen Sie in einem Crashkurs ganz schnell auf – dann kann nichts mehr schief gehen auf Ihrem Weg zur ersten Android-App.Leseprobe (PDF-Link)
Skalierbare Container-Infrastrukturen (3. Auflg.)
Das Handbuch für Administratoren. Die Referenz für DevOps-Teams und Admins in 3. Auflage 2020.Virtualisierung hat die nächste Evolutionsstufe erreicht – hochskalierbare, automatisierte und ausfallsichere Container-Umgebungen. Leistungsfähige IaaS/IaC-Mechanismen rollen Ihre virtuelle Infrastruktur auf Knopfdruck vollautomatisiert aus und provisionieren Cluster und Applikationen in jedem gewünschten Versionsstand. Mit GitOps-basierten, vollautomatisierten CI/CD-Pipelines, automatischer Skalierung von Applikationen und Cluster-Nodes on-demand, flexiblen Service-Meshes und Serverless-Architekturen sowie intelligenten Operatoren machen Sie Ihre Infrastruktur fit für die Zukunft.Die dritte, komplett überarbeitete Auflage der bewährten Container-Referenz liefert Ihnen tiefes, fundiertes Profi-Know-how und praxiserprobte Anleitungen. Sorgen Sie dafür, dass Ihr Unternehmen dank der aktuellsten Container-Technologien auf Basis von Kubernetes und OpenShift wettbewerbsfähig bleibt und bereits jetzt zukünftigen Anforderungen an Skalierbarkeit, Flexibilität, Hochverfügbarkeit und Planungssicherheit gewachsen ist!Container-Engines und Tools: CRI-O, Podman, Buildah, Skopeo und DockerProfessionelle Container-Orchestrierung mit Kubernetes und OpenShift, Vollautomation mit IaaS/IaC, intelligente Operatoren selbst erstellen und einsetzenService Meshes, Serverless-Architekturen und Integration von IDM-LösungenGitOps-basierte und vollautomatisierte Pipelines für maximale EffizienzStorage-Provisioner, containerisierte SDS-Lösungen, Security, Logging, Monitoring, Custom Metrics, Autoscaler und vieles mehr.Leseprobe (PDF-Link)
Dein iPhone 12
iPhone 12, iPhone 12 Pro, iPhone 12 Pro Max, iPhone 12 mini - einfach alles können. Inklusive Insidertipps zum aktuellen iOS 14.Die iPhone-iOS-Kombination bietet so viele Möglichkeiten, dass es nicht immer leichtfällt, den Überblick zu behalten. Dieses Buch des iPhone-Experten Philip Kiefer ist Ihr Kompass durch den Funktionsdschungel.Er erklärt leicht verständlich alle wichtigen Optionen der neuen iPhone-Modelle 12, 12 mini, 12 Pro und 12 Pro Max sowie der aktuellen iOS-Version 14: Sie nutzen die neue App-Mediathek, um Ihre Apps clever zu verwalten und wiederzufinden, senden Nachrichten, sind mit Safari im Internet unterwegs, mailen, fotografieren, telefonieren, tauschen Daten aus.Zudem bekommen Sie Infos zu vielen hilfreichen Apps und wie Sie Ihr iPhone vor ungewollten Zugriffen schützen können.Aus dem Inhalt:Ihr neues iPhone und iOS 14 kennenlernenIhr neues iPhone in Betrieb nehmen und clever bedienenApp Store, App-Mediathek und Co.: Apps finden, installieren, verwaltenMit dem iPhone telefonieren und chattenBehalten Sie mit dem iPhone Ihre Kontakte, Termine und Aufgaben im GriffIhre Befehle ausführen und Fragen beantworten: das kann SiriSo surfen Sie mit Ihrem iPhone 12 im InternetE-Mails senden und empfangen – das geht auch mit dem iPhoneMusik, Filme und weitere Medieninhalte auf dem iPhone abspielenMit der iPhone-Kamera tolle Fotos und Videos aufnehmenDas iPhone als hilfreicher Begleiter für unterwegsDie besten Apps für Shopping, Finanzen, Büro und mehrDaten sichern und austauschen – was Sie dazu wissen müssenVon Akku bis Zurücksetzen: alles zu Wartung und SicherheitInhalt & Leseprobe (PDF-Link)
Linux Mint - Einstieg und Umstieg
Dieses Buch richtet sich an Linux-Neulinge und Umsteiger von Windows oder macOS, die die beliebte Distribution Linux Mint einsetzen möchten.Leicht verständliche Schrittanleitungen und viele praktische Tipps helfen bei anfänglichen Startproblemen, die ein neues Betriebssystem mit sich bringen kann. Sie erfahren, was bei der Installation, den System- sowie Netzwerkeinstellungen zu beachten ist, und lernen geeignete Programme für Büro, Internet, Bildbearbeitung und Multimedia kennen, sodass Sie Linux Mint schnell produktiv im Alltag einsetzen.
Pro Google Cloud Automation
Discover the methodologies and best practices for getting started with Google cloud automation services including Google Cloud Deployment Manager, Spinnaker, Tekton, and Jenkins to automate deployment of cloud infrastructure and applications.The book begins with an introduction to Google cloud services and takes you through the various platforms available to do automation on the GCP platform. You will do hands-on exercises and see best practices for using Google Cloud Deployment Manager, Spinnaker, Tekton, and Jenkins. You’ll cover the automation aspects of the Google Cloud Platform holistically using native and upcoming open source technologies.The authors cover the entire spectrum of automation from cloud infrastructure to application deployment and tie everything together in a release pipeline using Jenkins. Pro Google Cloud Automation provides in-depth guidance on automation and deployment of microservices-based applications running on the Kubernetes platform. It provides sample code and best practice guidance for developers and architects for their automation projects on the Google Cloud Platform.This book is a good starting point for developers, architects, and administrators who want to learn about Google cloud automation.WHAT YOU WILL LEARN* Gain the fundamentals of Google’s automation-enabling services* See an architecture overview for Google Cloud Deployment Manager, Spinnaker, Tekton, and Jenkins* Implement automation for infrastructure and application use cases* Automate microservices-based applications running on GKE* Enable Google Cloud Deployment Manager, Spinnaker, Tekton, and Jenkins WHO THIS BOOK IS FORDevelopers, architects, and administrators who want to learn about Google cloud automation.Navin Sabharwal is an innovator, thought leader, author, and consultant in the areas of cloud computing, cloud lifecycle management, infrastructure as code, DevSecOps, AI, machine learning, big data analytics, and AIOPS. Navin has created niche award-winning products and solutions and has filed numerous patents in diverse fields such as IT services, assessment engines, ranking algorithms, capacity planning engines, and knowledge management.Piyush is a solution architect for automation, DevOps, and cloud services with overall ten years of IT experience. Piyush is currently working as a deputy general manager at HCL DRYiCE practice focusing on creating solutions catering to cloud adoption (including cloud landing zone, migration, and operations), automation, orchestration, and cloud lifecycle management.Chapter 1- Introduction to Google Cloud Automation Services• Google Cloud introduction• Introduction to Google Cloud Deployment Manager• Introduction to Spinnaker• Introduction to Kubernetes• Introduction to StackdriverChapter 2- Getting Started with Google Cloud Deployment Manager• Architecture overview of Google Cloud Deployment Manager• Hand on use case of Google Cloud Deployment ManagerChapter 3- Getting Started with Spinnaker• Architecture overview of Spinnaker• Getting started with setting up Spinnaker• Setting up integration• Hand on use case of CI/CD pipeline using SpinnakerChapter 4 – Getting Started with Kubernetes• Architecture overview of Kubernetes• Setting up Kubernetes• Hand on use case of GKE automation using KubernetesChapter 5- Getting Started with Stackdriver• Architecture overview of Stackdriver• Hand on use case of GCP monitoring• Runbook Automation use caseChapter 6- DevSecOps Automation• Scenarios of using Google Cloud Automation service• Hands on integrated use case of using all Automation services
MCA Microsoft Office Specialist (Office 365 and Office 2019) Study Guide
LEARN THE REALITIES OF BEING A MICROSOFT OFFICE SPECIALIST AND EFFICIENTLY PREPARE FOR THE WORD ASSOCIATE MO-100 EXAM WITH A SINGLE, COMPREHENSIVE STUDY GUIDEMCA Microsoft Office Specialist Study Guide: Word Associate Exam MO-100 comprehensively prepares you for the MO-100 Exam. Accomplished and experienced author Eric Butow provides readers with a one-stop resource for learning the job responsibilities of a Microsoft Office Specialist and succeeding on the MO-100 Exam.The study guide is written in a straightforward and practical style which, when combined with the companion online Sybex resources, allows you to learn efficiently and effectively. The online resources include hundreds of practice questions, flashcards, and a glossary of key terms. In addition to preparing you for the realities of the Microsoft Office Specialist job role, this study guide covers all the subjects necessary to do well on the certifying exam, including:* Managing documents* Inserting and formatting text, paragraphs, and sections* Managing tables and lists* Creating and managing references* Inserting and formatting graphics* Managing document collaborationPerfect for anyone seeking to begin a new career as a Microsoft Office Specialist, or simply wondering what the job entails, the Study Guide also belongs on the bookshelf of currently practicing professionals who want to brush up on the fundamentals of their role.ERIC BUTOW is the author or coauthor of 35 books on multiple aspects of technology. He has also developed and taught networking, computing, and usability courses for Ed2Go, Virtual Training Company, California State University/Sacramento, and Udemy. Eric began using Word, Excel, and PowerPoint professionally in 1992. He has been a technical writer for large and small companies, and presently provides website development, online marketing, and technical writing services through his company, Butow Communications Group. Introduction xviiAssessment Test xxiiCHAPTER 1 WORKING WITH DOCUMENTS 1Navigating Within Documents 2Searching for Text 2Linking to Locations Within Documents 6Moving to Specific Locations and Objects in Documents 7Showing and Hiding Formatting Symbols and Hidden Text 8Formatting Documents 11Setting Up Document Pages 12Applying Style Settings 13Inserting and Modifying Headers and Footers 15Configuring Page Background Elements 16Saving and Sharing Documents 18Saving Documents in Alternative File Formatting 18Changing Basic Document Properties 19Modifying Print Settings 21Sharing Documents Electronically 22Inspecting Documents for Issues 24Locating and Removing Hidden Properties and Personal Information 24Finding and Fixing Accessibility Issues 26Locating and Correcting Compatibility Issues 27Summary 28Key Terms 29Exam Essentials 29Review Questions 31CHAPTER 2 INSERTING AND FORMATTING TEXT 33Adding and Replacing Text 34Finding and Replacing Text 34Inserting Symbols and Special Characters 38Formatting Text and Paragraphs 40Adding Text Effects 40Applying Formatting by Using Format Painter 41Setting Line and Paragraph Spacing and Indentation 41Applying Built-In Styles to Text 44Clearing Formatting 45Creating and Configuring Document Sections 48Formatting Text in Multiple Columns 48Inserting Page, Section, and Column Breaks 50Changing Page Setting Options for a Section 51Summary 54Key Terms 55Exam Essentials 55Review Questions 56CHAPTER 3 MANAGING TABLES AND LISTS 59Creating Tables 60Converting Text to Tables 62Switching Tables to Text 63Creating Tables by Specifying Rows and Columns 64Modifying Tables 66Sorting Table Data 66Configuring Cell Margins and Spacing 68Merging and Splitting Cells 71Resizing Tables, Rows, and Columns 73Splitting Tables 78Configuring a Repeating Row Header 80Creating and Formatting Lists 83Structuring Paragraphs as Numbered and Bulleted Lists 83Changing Bullet Characters and Number Formatting 84Defining Custom Bullet Characters and Number Formatting 86Increasing and Decreasing List Levels 89Restarting and Continuing List Numbering 90Setting Starting Number Values 92Summary 93Key Terms 94Exam Essentials 94Review Questions 95CHAPTER 4 BUILDING REFERENCES 97Creating and Managing Referencing Elements 98Inserting Footnotes and Endnotes 98Modifying Footnote and Endnote Properties 101Creating and Modifying Bibliography Citation Sources 102Inserting Citations for Bibliographies 105Working with Referencing Tables 107Inserting Tables of Contents 107Customizing Tables of Contents 108Adding Bibliographies 110Summary 111Key Terms 111Exam Essentials 112Review Questions 113CHAPTER 5 ADDING AND FORMATTING GRAPHIC ELEMENTS 115Inserting Illustrations and Text Boxes 116Adding Shapes 116Including Pictures 118Inserting 3D Models 119Adding SmartArt Graphics 120Placing Screenshots and Screen Clippings 121Inserting Text Boxes 123Formatting Illustrations and Text Boxes 125Applying Artistic Effects 125Adding Picture Effects and Picture Styles 126Removing Picture Backgrounds 129Formatting Graphic Elements 130Setting Up SmartArt Graphics 132Working with 3D Models 134Adding and Organizing Text 135Formatting Text in Text Boxes 135Adding Text in Shapes 137Changing SmartArt Graphic Content 139Modifying Graphic Elements 140Positioning Objects 140Wrapping Text Around Objects 141Adding Alt Text to Objects 144Summary 146Key Terms 146Exam Essentials 146Review Questions 147CHAPTER 6 WORKING WITH OTHER USERS ON YOUR DOCUMENT 149Adding Comments 150Inserting Comments 150Reviewing and Replying to Comments 151Resolving Comments 152Deleting Comments 153Tracking Your Changes 155Turning On Track Changes 155Reviewing Tracked Changes 156Accepting and Rejecting Tracked Changes 157Locking and Unlocking Change Tracking 160Summary 163Key Terms 163Exam Essentials 163Review Questions 164APPENDIX ANSWERS TO REVIEW QUESTIONS 167Chapter 1: Working with Documents 168Chapter 2: Inserting and Formatting Text 168Chapter 3: Managing Tables and Lists 169Chapter 4: Building References 170Chapter 5: Adding and Formatting Graphic Elements 170Chapter 6: Working with Other Users on Your Document 171Index 173
Custom Fiori Applications in SAP HANA
Get started building custom Fiori applications for your enterprise. This book teaches you how to design, build, and deploy enterprise-ready, custom Fiori applications in SAP HANA. Tips and tricks collected from projects using Fiori applications (built consuming OData models and REST APIs) and integrating third-party JS libraries are presented. Also included are examples using Fiori templates from different tools such as the SAP Web IDE and the new Visual Studio Code extensions.This book explains the 5 design principles that all Fiori applications are built upon: Role-based, Responsive, Coherent, Simple, and Delightful. The book expands on consuming OData services and REST APIs internal and external to SAP HANA. The Fiori application exercise demonstrates the use of the MVC pattern, JavaScript modularization, reuse of SAP UI5 controls, debugging, and the tools required for a complete scenario. The book closes with an exercise showcasing a finished single page application with multiple views and layouts, navigation between the views, and deployment of the application to AWS.This book is simple enough for entry-level developers getting started in web frameworks but also highlights integration points from the data models being consumed from the application, and shows how the application communicates with back-end services, resulting in a complete front-end custom Fiori application.WHAT YOU WILL LEARN* Know the 5 Fiori design principles* Understand how to consume OData and REST API models* Apply the MVC pattern using XML views and the SAP UI5 controls along with controller behavior in JavaScript* Debug and deploy the applicationWHO THIS BOOK IS FORWeb developers and application leads who have some experience in JavaScript frameworks and web development and understand web protocol communicationSERGIO GUERRERO is a passionate software engineer with 10+ years of experience in web and database development in various technology stacks such as .NET and SAP HANA. He is the author of Microservices on SAP HANA XSA (Apress). On non-working days, Sergio cheers for the Green Bay Packers and Tigres UANL (MX soccer), Chapter 1: Fiori Applications in SAP HANACHAPTER GOAL: The goal is to explain what Fiori is and how it is developed in SAP HANA. There are five design principles for Fiori applications.NO OF PAGES 30SUB -TOPICS1. What is Fiori?2. Five design principles of Fiori3. Getting your system ready for Fiori applications4. Understanding layouts and floor plansChapter 2: Consuming Data in Fiori ApplicationsCHAPTER GOAL: This chapter explains how to mock data, how to consume data, how to understand and prepare data for the Fiori application.NO OF PAGES:SUB - TOPICS1. Understanding data and mocking it when not available2. OData and JSON Models3. Consuming REST APIs4. Data driven design approachesChapter 3: Fiori Application following the MVCCHAPTER GOAL: the goal for this chapter is to understand the moving pieces to create a Fiori applicationNO OF PAGES : 30SUB - TOPICS:1. MVC2. Tools for developing and debugging Fiori applications3. Integrating external JS libraries into (SAPUI5) Fiori4. Browser differences, limitations, and features5. Fiori application on various devicesChapter 4: Unit Testing of Fiori ApplicationsCHAPTER GOAL: The goal of this chapter is to start with unit testing, comparing different unit test frameworks and finish with an automated testing scenarioNO OF PAGES: 30SUB - TOPICS:1. Unit testing frameworks2. Fiori app unit testing3. Improvements resulting from unit testingChapter 5: Deploying Fiori ApplicationCHAPTER GOAL: The goal of the chapter is to help the reader to complete the software development cycle and be able to deploy the Fiori application to a production environment.1. Preparing the deployment, software versioning2. Deploying to different platforms such as SAP Cloud and AWS3. Automating deployment
Introduction to Programming with C++ for Engineers
A complete reference for engineers to learn the fundamentals of C and C++ programming Introduction to Programming with C++ for Engineers is an original presentation teaching the fundamentals of both C and C++ to engineers and engineering students. With a focus on providing a quick but manageable learning curve for programming novices, this book provides comprehensive lessons in object-oriented programming in C and C++. Professor Cyganek, a highly regarded expert in his field, walks users through the basics of C and C++ programming simultaneously, showing with real world examples how to complete tasks in both languages. He also guides users through the installation process of the C and C++ programming environments in both Linux and Windows. Introduction to Programming with C++ for Engineers teaches novices how to program by: * Granting access to a complementary website that contains example code and useful links to resources that further improve the reader's coding ability * Minimizing text descriptions, opting instead for figures, tables, diagrams, and other explanatory material * Covering C++20 * Including test and exam questions for the reader's review at the end of each chapter Engineering students, students of other sciences who rely on computer programming, and professionals in various fields will find this book invaluable when first learning to program in C and C++. A complete textbook and reference for engineers to learn the fundamentals of computer programming with modern C++ Introduction to Programming with C++ for Engineers is an original presentation teaching the fundamentals of computer programming and modern C++ to engineers and engineering students. Professor Cyganek, a highly regarded expert in his field, walks users through basics of data structures and algorithms with the help of a core subset of C++ and the Standard Library, progressing to the object-oriented domain and advanced C++ features, computer arithmetic, memory management and essentials of parallel programming, showing with real world examples how to complete tasks. He also guides users through the software development process, good programming practices, not shunning from explaining low-level features and the programming tools. Being a textbook, with the summarizing tables and diagrams the book becomes a highly useful reference for C++ programmers at all levels. Introduction to Programming with C++ for Engineers teaches how to program by: * Guiding users from simple techniques with modern C++ and the Standard Library, to more advanced object-oriented design methods and language features * Providing meaningful examples that facilitate understanding of the programming techniques and the C++ language constructions * Fostering good programming practices which create better professional programmers * Minimizing text descriptions, opting instead for comprehensive figures, tables, diagrams, and other explanatory material * Granting access to a complementary website that contains example code and useful links to resources that further improve the reader’s coding ability * Including test and exam question for the reader’s review at the end of each chapter Engineering students, students of other sciences who rely on computer programming, and professionals in various fields will find this book invaluable when learning to program with C++. Prof. Boguslaw Cyganek, Department of Electronics, AGH, University of Science and Technology, Krakow, Poland. Boguslaw Cyganek obtained his Ph.D. degree cum laude in 2001 with a thesis on correlation of stereo images, and D.Sc. degree in 2011 with a thesis on methods and algorithms of object recognition in digital images. During recent years, Dr. Cyganek has been cooperating with many scientific centers in development of computer vision systems. He has also gained several years of practical experience working as a Software Development Manager and a Senior Software Engineer both in the USA and Poland. He is an author or a co-author of over ninety conference and journal papers and four books including "An Introduction to 3D Computer Vision Techniques and Algorithms", as well as "Object Detection and Recognition in Digital Images: Theory and Practice", published by Wiley. Dr. Cyganek is a member of the IEEE, SPIE, IAPR and SIAM. Preface xi Acknowledgments xiii Abbreviations xv About the Companion Website xvii 1 Introduction 1 1.1 Structure of the Book 5 1.2 Format Conventions 8 1.3 About the Code and Projects 9 2 Introduction to Programming 13 2.1 Hardware Model 13 2.2 Software Development Ecosystem 16 2.3 Software Development Steps 18 2.4 Representing and Running Algorithms 20 2.4.1 Representing Algorithms 21 2.4.2 Using Online Compilers 22 2.4.3 Structure of a C++ Program 24 2.4.4 Code Analysis 24 2.4.5 Building a Linux Executable 26 2.5 Example Project – Compound Interest Calculator 29 2.5.1 Compound Interest Analysis 29 2.5.2 Implementation of the Interest Calculator 30 2.5.3 Building and Running the Software 33 2.6 Example Project – Counting Occurrences of Characters in Text 34 2.6.1 Problem Analysis and Implementation 34 2.6.2 Running the C++ Code with the Online Compiler 35 2.6.3 Histogram Code, Explained 36 2.7 Summary 39 Questions and Exercises 39 3 C++ Basics 43 3.1 Constants and Variables – Built-In Data Types, Their Range, and Initialization 43 3.2 Example Project – Collecting Student Grades 53 3.3 Our Friend the Debugger 56 3.4 The Basic Data Structure – std::vector 59 3.5 Example Project – Implementing a Matrix as a Vector of Vectors 64 3.6 Special Vector to Store Text – std::string 67 3.7 Using the auto Keyword and decltype for Automatic Type Deduction 72 3.8 Common Standard Algorithms 75 3.9 Structures: Collecting Objects of Various Types 79 3.10 Fixed-Size Arrays 83 3.10.1 Multidimensional Fixed-Size Arrays 85 3.11 References 87 3.12 Pointers 90 3.12.1 Object Access with Pointers 90 3.13 Statements 95 3.13.1 Blocks of Statements and Access to Variables – The Role of Braces 95 3.13.2 C++ Statements 97 3.13.2.1 Conditional Statements 97 3.13.2.2 Loop Statements 103 3.13.2.3 Auxiliary Statements – continue and break 108 3.13.2.4 The goto Statement 110 3.13.2.5 Structural Exception Handling – The try-catch Statement 110 3.14 Functions 112 3.14.1 Anatomy of a Function in C++ 112 3.14.2 Passing Arguments to and from a Function 117 3.14.2.1 Argument Passing by Copy (Value Semantics) 118 3.14.2.2 Indirect Argument Passing by Reference 119 3.14.2.3 Passing by Pointer 121 3.14.3 Function Call Mechanism and Inline Functions 123 3.14.4 Recursive Functions and the Call Stack 125 3.14.5 Function Overloading – Resolving Visibility with Namespaces 126 3.14.6 Lambda Functions 128 3.14.7 More on Lambda Functions 132 3.14.8 Function Pointers 138 3.14.9 Functions in an Object-Oriented Framework 140 3.15 Example Project – Wrapping Objects in a Structure with a Constructor 142 3.15.1 EMatrix in an Object-Oriented Environment 145 3.15.2 Basic Operations with EMatrix 145 3.15.3 Input and Output Operations on EMatrix 147 3.15.4 Basic Mathematical Operations on EMatrix 148 3.15.5 Organizing the Project Files and Running the Application 150 3.15.6 Extending Matrix Initialization with a Simple Random Number Generator 153 3.16 Example Project – Representing Quadratic Equations 154 3.16.1 Definition of a Class to Represent Quadratic Polynomials 155 3.16.2 TQuadEq Member Implementation 162 3.16.3 TQuadEq in Action 165 3.17 Example Project – Tuples and Structured Bindings for Converting Roman Numerals 167 3.17.1 More on std::tuple and the Structured Binding 170 3.17.2 How to Write a Software Unit Test 173 3.17.3 Automating Unit Tests – Using the Standard Random Number Library 174 3.18 Example Project – Building a Currency Calculator Component 176 3.18.1 Currency Exchange Problem Analysis 177 3.18.2 CurrencyCalc Software Design 179 3.18.3 TCurrency Class Representing Currency Records 181 3.18.3.1 C++ Input/Output Manipulators 183 3.18.4 TCurrencyExchanger Class for Exchanging Currency 186 3.18.5 Putting It All Together – The Complete Currency Exchange Program 190 3.19 Operators 196 3.19.1 Summary of the C++ Operators 199 3.19.2 Further Notes on Operators 222 3.20 Summary 223 Questions and Exercises 224 4 Delving into Object-Oriented Programming 227 4.1 Basic Rules and Philosophy of Object-Oriented Design and Programming 227 4.2 Anatomy of a Class 231 4.2.1 Naming Conventions and Self-Documenting Code 233 4.3 Rules for Accessing Class Members 233 4.4 Example Project – TComplex Class for Operator Overloading 235 4.4.1 Definition of the TComplex Class 236 4.4.2 Definition of the TComplex Class Members 241 4.4.3 Test Functions for the TComplex Class 243 4.5 More on References 246 4.5.1 Right and Forward References 246 4.5.2 References vs. Pointers 251 4.5.3 Pitfalls with References 252 4.6 Example Project – Mastering Class Members with the TheCube Class 253 4.6.1 Automatic vs. Explicit Definition of the Constructors 254 4.6.2 TheCube Object Layout and Semantics 264 4.6.3 Shallow vs. Deep Copy Semantics 265 4.6.4 Move Constructor and Move Assignment Semantics 266 4.6.5 Implementation of the TheCube Streaming Operators 267 4.6.6 Validation of TheCube 269 4.7 Example Project – Moving EMatrix to the Class 272 4.7.1 Definition of the EMatrix Class 272 4.7.2 Implementation of the Class Streaming Operators 274 4.7.3 Implementation of the Arithmetic Operators 278 4.7.4 Testing Matrix Operations 279 4.8 Introduction to Templates and Generic Programming 281 4.8.1 Generalizing a Class with Templates 282 4.8.2 Template Specializations 286 4.8.3 Template Functions and Type Checking 287 4.8.4 Example Project – Designing Template Classes with TStack 289 4.8.4.1 Design and Implementation of the TStackFor Class 290 4.8.4.2 Testing TStack 293 4.8.5 Template Member Functions 294 4.9 Class Relations – “Know,” “Has-A,” and “Is-A” 297 4.10 Example Project – Extending Functionality Through Class Inheritance with TComplexQuadEq 304 4.11 Virtual Functions and Polymorphism 310 4.12 More on the Virtual Mechanism 316 4.13 The Curiously Recurring Template Pattern and Static Polymorphism 318 4.14 Mixin Classes 322 4.15 Example Project – The TLongNumberFor Class for Efficient Storage of Numbers of Any Length 323 4.15.1 Binary-Coded Decimal Representation 325 4.15.2 Endianness 326 4.15.3 Definition of the TLongNumberFor Class 326 4.15.3.1 Type-Converting Operations 329 4.15.3.2 TLongNumberFor Test Function 333 4.15.4 Designing Classes for PESEL IDs 335 4.15.4.1 Aggregating PESEL 336 4.15.4.2 Inherited PESEL 337 4.15.4.3 LongNumber Project Organization 338 4.15.5 Extending the Functionality of TLongNumberFor with the Proxy Pattern 340 4.15.5.1 Definition of the Proxy Class 341 4.15.5.2 Testing the Functionality of the TLongNumberFor Class with the Proxy Pattern 343 4.16 Strong Types 345 4.17 Summary 346 Questions and Exercises 346 5 Memory Management 349 5.1 Types of Data Storage 349 5.2 Dynamic Memory Allocation – How to Avoid Memory Leaks 349 5.2.1 Introduction to Smart Pointers and Resource Management 358 5.2.1.1 RAII and Stack Unwinding 359 5.3 Smart Pointers – An Overview with Examples 360 5.3.1 More on std::unique_ptr 360 5.3.1.1 Context for Using std::unique_ptr 360 5.3.1.2 Factory Method Design Pattern 374 5.3.1.3 Custom deletes for unique_ptr 376 5.3.1.4 Constructions to Avoid When Using unique_ptr 378 5.3.2 More on shared_ptr and weak_ptr 378 5.4 Summary 381 Questions and Exercises 381 6 Advanced Object-Oriented Programming 383 6.1 Functional Objects 383 6.2 Example Project – Extending the Currency Search in XML Files, and Using State Machine and Regular Expressions with the regex Library 389 6.2.1 Pattern Matching with the Regular Expression Library 390 6.2.2 State Machine Pattern 392 6.2.3 Implementing the Extended Class 393 6.2.4 Project Extension – Loading Currency Information from the Internet 399 6.2.5 Launching the Extended Version of CurrencyCalc 405 6.2.6 Building a Static Library and a Terminal Window Application 409 6.2.7 C++ Filesystem 410 6.2.8 User Interface 419 6.2.8.1 Definition of the CC_GUI Class 420 6.2.8.2 Definitions of Members of the CC_GUI Class and the Callback Mechanism 423 6.2.8.3 Launching the GUI-Based Application 430 6.3 System Clocks and Time Measurements 431 6.4 Time Measurement for Function Execution 435 6.5 Range Class 437 6.5.1 Functional Programming and the Ranges Library 442 6.6 Example Project – Parsing Expressions 443 6.6.1 Defining Language Expressions with Formal Grammar Rules 444 6.6.2 Design of the Expression-Processing Framework 446 6.6.3 The First Expression Interpreter 447 6.6.4 Building the Syntax Tree with the Composite Design Pattern 451 6.6.4.1 The Composite Design Pattern to Define the Nodes of a Tree 452 6.6.4.2 Implementation of the TNode Hierarchy and Cooperation with Visitors 453 6.6.4.3 Implementation of the ValueLeafNode Class 455 6.6.4.4 Implementation of the BinOperator Class 457 6.6.4.5 Implementation of the PlusOperator Class 458 6.6.4.6 Deep Copying Node Objects – The Prototyping Mechanism 459 6.6.5 Interpreter to Build a Syntax Tree 460 6.6.6 Stack for Smart Pointers 466 6.6.7 Traversing Trees with the Visitor Design Pattern 469 6.6.7.1 The Expression-Evaluating Visitor 472 6.6.7.2 The Expression-Printing Visitor 474 6.6.8 Testing the Interpreters 476 6.6.9 Representing Expressions on a Stack in Reverse Polish Notation 479 6.6.9.1 Reverse Polish Notation 479 6.6.9.2 Algorithm for Evaluating an RPN Expression 480 6.7 Summary 485 Questions and Exercises 485 7 Computer Arithmetic 489 7.1 Integer Value Representation 489 7.1.1 Base Conversion Algorithm 491 7.1.2 Hexadecimal and Octal Representations 492 7.1.3 Binary Addition 493 7.1.4 Negative Values and Subtraction 494 7.1.5 Arithmetic Control Flags 496 7.1.6 Representing Fractions 498 7.2 Binary Shift Operations 501 7.3 Example Project – Software Model for Fixed-Point Representations 503 7.3.1 Fixed-Point Numbers and Their Arithmetic 503 7.3.2 Definition of the FxFor Class 504 7.3.3 Selected Methods of the FxFor Class 510 7.3.4 Applications of FxFor 516 7.4 Floating-Point Representations 519 7.4.1 Number Representation in Floating-Point Format 520 7.4.2 Distribution of Floating-Point Numbers and the Computational Consequences 524 7.4.3 Real-Value Approximation Error with Floating-Point Representations 527 7.4.4 The IEEE 754 Standard for Floating-Point Arithmetic 530 7.4.5 The Standard FP Operation Model 537 7.4.6 Computations That Are Conscious of Numerical Errors 537 7.4.7 Example Project – Evaluating the Summation Algorithms 539 7.4.8 Example Project – The Newton Method of Finding the Roots of a Function 544 7.4.8.1 Function to Compute Square Roots Based on Newton’s Iteration 548 7.5 Summary 550 Questions and Exercises 551 8 Basics of Parallel Programming 553 8.1 Basic Concepts of Parallel Computations 553 8.2 Adding Parallelism to the Standard Algorithms 556 8.3 Launching Asynchronous Tasks 559 8.4 Parallelization with the OpenMP Library 561 8.4.1 Launching a Team of Threads and Providing Exclusive Access Protection 562 8.4.2 Loop Parallelization and Reduction Operations 564 8.4.3 Massive Data Parallelization 567 8.5 Summary 575 Questions and Exercises 575 Appendix 577 A.1 Preprocessor Directives 577 A.2 Short Introduction to C 582 A.2.1 Built‐in Arrays 583 A.2.1.1 Multidimensional Fixed-Size Arrays 585 A.2.2 Passing Arrays to Functions – The Main Function 586 A.2.3 C Structures 590 A.2.4 C Functions and Input/Output 591 A.2.5 Unions 592 A.2.6 Memory and String Operations 593 A.2.7 Binding C and C++ Code 599 A.3 Linking and Binary Organization of C/C++ Objects 599 A.4 Graphical User and Web Interfaces for C++ Projects 601 A.5 Converting Bin, Oct, Dec, and Hex Values with FixBinCalc 603 A.6 Programming Toolchain 604 A.6.1 Project-Generating Tool (CMake) 604 A.6.2 Source Version Control and Repositories 609 A.6.3 Profiler 610 A.7 Software Testing 612 A.8 Summary 616 Questions and Exercises 616 Bibliography 619 Index 623
Spiele programmieren mit Unity für Kids (2. Auflg.)
Mit Spaß 3D-Spiele selbst entwickeln.Unity ist eine sehr beliebte Spiele-Engine, mit der du eigene 3D-Spiele entwickeln kannst. Der erfahrene Kids-Autor Hans-Georg Schumann zeigt dir, wie du mit Unity und der Programmiersprache C# schnell zu beeindruckenden Ergebnissen kommst. Schritt für Schritt lernst du, wie du Figuren durch die Welt wandern und auch gegen gefährliche Gegner kämpfen lässt. Du erstellst Landschaften mit Bäumen und Seen, gestaltest und animierst eigene Charaktere, und lernst ganz nebenbei das Programmieren in C#. Das Unity-Partikelsystem erzeugt tolle Effekte mit Licht und Schatten, die dem Spiel das nötige Reality-Gefühl geben. Und alles, was du zum Programmieren deiner Spiele brauchst, findest du auch zum Download.Aus dem Inhalt: Unity starten und ein erstes kleines Kollisionsspiel erstellenIn die Script-Programmierung mit C# einsteigenEinen Charakter entwerfen und ihm Eigenschaften gebenEin Jump & Run-Spiel entwickelnDas Prinzip von 3D verstehen und die Spielfläche mit Bäumen und Wasser gestaltenGanze Bauwerke entstehen lassenDie Figur klettern, schwimmen und sogar tauchen lehrenEine Fantasie-Kreatur entwerfen und durch Animation lebendig werden lassenStrahlen, Partikel und Sound einbindenKünstliche Intelligenz nutzenEnergiekontrolle und andere Features aufrüstenInstallationshilfe und Fehlerbehebung Inhaltsverzeichnis & Leseprobe (PDF-Link)Kostenlose Downloads zum Buch (Zip-Link)
Soziale Medien
Bildeten noch vor wenigen Jahren Presse, Rundfunk und Fernsehen den primären Zugang der Gesellschaft zu sich selbst, sind heutige gesellschaftliche Debatten sowie das Phänomen der Öffentlichkeit in hohem Maße durch den Einfluss von Social Media geprägt. Das Neue der dortigen Kommunikation ist, dass sie durch algorithmische Selektionen vorgeformt wird, in hohem Maße personalisiert ist und Beiträge automatisierter Accounts enthalten kann. Diese Charakteristika stellen die Forschung in der Einordnung und Bewertung des gesellschaftlichen Einflusses von Social Media-Debatten immer noch vor Schwierigkeiten und verlangen nach transdisziplinären Ansätzen. Beiträge aus der Informatik und den Computational Humanities ergänzen deshalb die medien- und kommunikationswissenschaftlichen Perspektiven jeweils um eine Beschreibung der technischen Grundlagen ihrer Untersuchungsgegenstände und der möglichen Zugänge zum Objektbereich.SAMUEL BREIDENBACH, M.A., ist Stipendiat der Graduate Research School der Brandenburgischen Technischen UniversitätPETER KLIMCZAK, Dr. phil. et Dr. rer. nat. habil., ist Privatdozent an der MINT-Fakultät der Brandenburgischen Technischen Universität.CHRISTER PETERSEN, Dr. phil., ist Professor für Angewandte Medienwissenschaften an der Brandenburgischen Technischen Universität.Gesellschaftliche Funktionen von Social Media.-Aktualität und Relevanz in Social Media-Plattformen.-Strategien und Methoden des digitalen Protests.-Technische Dispositionen der Kommunikation in Social Media.-Algorithmische Selektion.-Automatisierte Kommunikation (Social Bots).- Social Media Analytics.
SAP für Anwender - Tipps & Tricks
Leichter arbeiten mit SAP ERP! Ob in Controlling, Buchhaltung, Einkauf, Vertrieb, Disposition oder Personalwesen: Wenn Sie regelmäßig mit einem SAP-System arbeiten, ist dieses Buch wie für Sie gemacht. Aus eigener Erfahrung wissen Wolfgang und Dennis Fitznar, wo sich SAP-Anwender*innen schwer tun, und greifen tief in ihre Trickkisten. Tipp für Tipp erfahren Sie, wie Sie komfortabler im System navigieren, blitzschnell Daten pflegen und das SAP-System für sich arbeiten lassen. Aus dem Inhalt: Komfortabel am System anmeldenAnzeigeeinstellungen optimierenSchneller im System navigierenVorschlagswerte einsetzenDaten erfassenDaten pflegenMit F4-Hilfen Daten schnell findenDaten gezielt selektierenALV-Auswertungen optimierenDruck und DownloadAbläufe mithilfe von Jobs automatisierenMakros für wiederkehrende Aufgaben Vorwort zur zweiten Auflage ... 13 Einleitung ... 15 TEIL 1. Komfortabel am System anmelden ... 19 Tipp 1 ... Checkliste: Die wichtigsten Einstellungen nach der Erstanmeldung ... 20 Tipp 2 ... Schneller anmelden mit Desktopverknüpfungen ... 23 Tipp 3 ... Felder im Einstiegsbild mithilfe einer Desktopverknüpfung vorbelegen ... 28 Tipp 4 ... Desktopverknüpfung bearbeiten ... 34 Tipp 5 ... SAP-Anmeldung direkt mit Windows starten ... 36 Tipp 6 ... Zweiten Modus nach der Anmeldung sparen ... 38 TEIL 2. Anzeigeeinstellungen optimieren ... 41 Tipp 7 ... Welches Theme ist besser für mich: Belize oder Signature? ... 42 Tipp 8 ... Systeme und Mandanten mit Farben leichter unterscheiden ... 46 Tipp 9 ... Eigene Bildschirmfarben für SAP GUI definieren ... 49 Tipp 10 ... Aktives Feld durch Fokus schneller erkennen ... 51 Tipp 11 ... Quickinfo beschleunigen ... 54 Tipp 12 ... Weg mit überflüssigen Meldungsfenstern! ... 56 TEIL 3. Surfin' SAP -- schneller im System navigieren ... 61 Tipp 13 ... Transaktionen im SAP-Menü schneller finden ... 62 Tipp 14 ... In Baumstrukturen schneller navigieren ... 65 Tipp 15 ... Favoritenmenü optimal anlegen ... 67 Tipp 16 ... Favoritenmenüs teilen ... 72 Trick17 ... Mit Befehlsfeld navigieren ... 76 Tipp 18 ... Mit /* das Einstiegsbild überspringen ... 79 Tipp 19 ... Befehlsfeld als multiple Zwischenablage nutzen ... 82 Tipp 20 ... Mit Doppelklicks schneller navigieren ... 85 Tipp 21 ... Mit den Menüs »Umfeld« und »Springen« navigieren ... 89 Tipp 22 ... Mit Kontextmenüs und Standard-Funktionstasten navigieren ... 93 Tipp 23 ... Transaktionen mit eigenen Tastenkombinationen starten ... 96 Tipp 24 ... SAP-Verknüpfungssymbole auf dem Desktop optimieren ... 101 TEIL 4. Vorschlagswerte einsetzen ... 105 Tipp 25 ... Vorschlagswerte aus der Historie nutzen ... 106 Tipp 26 ... Zentrale Vorschlagswerte in Benutzerparametern definieren ... 109 Tipp 27 ... Parameter-IDs mit der technischen Info finden ... 115 Tipp 28 ... Transaktionsspezifische Vorschlagswerte definieren ... 119 Tipp 29 ... Temporäre Vorschlagswerte für einzelne Masken definieren ... 125 Tipp 30 ... Vorschlagswert für ein Feld mit mehreren möglichen Werten setzen ... 129 TEIL 5. Daten erfassen ... 131 Tipp 31 ... Stammdaten mit Vorlagen erfassen ... 132 Tipp 32 ... Belege mit Vorlagen erfassen ... 136 Tipp 33 ... Zeilen in Erfassungstabellen kopieren ... 140 Tipp 34 ... Tabellenteile kopieren ... 143 Tipp 35 ... Feldinhalte schneller kopieren ... 147 Tipp 36 ... Tastatureinstellungen für die Datenerfassung optimieren ... 152 Tipp 37 ... Spaltenreihenfolge in Erfassungstabellen ändern (Table Control) ... 155 Tipp 38 ... Mehrere Table Controls verwenden ... 159 Tipp 39 ... Datumswerte schneller erfassen ... 161 TEIL 6. Daten pflegen ... 165 Tipp 40 ... Schnelländerungen in Belegen und Beleglisten durchführen ... 166 Tipp 41 ... Persönliche Notizen ergänzen ... 171 Tipp 42 ... Öffentliche Notizen ergänzen ... 175 Tipp 43 ... PC-Dateien als Anlagen speichern ... 178 Tipp 44 ... Upload-Ordner einstellen ... 183 Tipp 45 ... Klarnamen aus Benutzernamen ermitteln ... 186 Tipp 46 ... Expressmail wegen Datensperrung verschicken ... 190 Tipp 47 ... Mit der Objekthistorie letzte Änderungen finden ... 193 Tipp 48 ... Änderungslisten für Stammsätze und Belege anzeigen ... 196 TEIL 7. Mit F4-Hilfen Daten schnell finden ... 201 Tipp 49 ... »Magisches Dreieck« für Suchhilfen nutzen ... 202 Tipp 50 ... Nummern für Stammdaten und Belege schneller finden ... 206 Tipp 51 ... Persönliche Wertelisten erstellen ... 211 Tipp 52 ... Persönliche Wertelisten bearbeiten ... 216 Tipp 53 ... Persönliche Wertelisten standardmäßig anzeigen ... 219 Tipp 54 ... Maximale Trefferanzahl dauerhaft ändern ... 221 Tipp 55 ... Volltreffer direkt in das Eingabefeld übernehmen ... 223 Tipp 56 ... Voreinstellungen für einzelne Wertelisten durchführen ... 226 TEIL 8. Daten gezielt selektieren ... 231 Tipp 57 ... Daten mit Kopfparametern schneller selektieren ... 232 Tipp 58 ... Langläufer abbrechen ... 235 Tipp 59 ... Mit Jokern flexibler selektieren ... 237 Tipp 60 ... Mit dem Joker * Mussfelder austricksen ... 239 Tipp 61 ... Selektionsoptionen nutzen ... 241 Tipp 62 ... Leere Felder selektieren ... 244 Tipp 63 ... Mehrfachselektionen mit Upload vereinfachen ... 247 Tipp 64 ... Zusätzliche Selektionsfelder aus freien Abgrenzungen nutzen ... 252 Tipp 65 ... Vorschlagswerte in Reportvarianten speichern ... 256 Tipp 66 ... Reportvarianten ändern und löschen ... 262 Tipp 67 ... Felder in Reportvarianten ausblenden und schützen ... 265 Tipp 68 ... Datumsangaben in Reportvarianten dynamisch vorbelegen ... 268 TEIL 9. Layouts mit dem SAP List Viewer erstellen und verwalten ... 275 Tipp 69 ... ALV-Darstellungen kennenlernen ... 276 Tipp 70 ... In die optimale ALVDarstellung wechseln ... 280 Tipp 71 ... Vorgefertigte Layouts verwenden ... 285 Tipp 72 ... Nützliche Funktionen für ALVListen finden ... 289 Tipp 73 ... Markierungen in ALV-Listen durchführen ... 293 Tipp 74 ... Spalten kombinieren (ALV Grid) ... 296 Tipp 75 ... Spalten kombinieren (ALV Classic) ... 300 Tipp 76 ... Schatzsuche im ALV: Verborgene Spalten sichtbar machen ... 304 Tipp 77 ... Layout speichern und voreinstellen ... 307 Tipp 78 ... Layout nachträglich ändern ... 311 Tipp 79 ... Layoutvoreinstellung wechseln ... 315 Tipp 80 ... Layout löschen ... 318 TEIL 10. Layouts optimieren ... 321 Tipp 81 ... Spalten am linken Rand fixieren ... 322 Tipp 82 ... Spaltenbreiten optimieren ... 326 Tipp 83 ... Schnelle Berechnungen erstellen ... 329 Tipp 84 ... Mehrstufige Zwischensummen erstellen (ALV Grid) ... 334 Tipp 85 ... Summenauswertungen erstellen ... 338 Tipp 86 ... Tabellenlöcher nach Mehrfachsortierung stopfen ... 343 Tipp 87 ... Die zweite Chance: Mit Filtern nachselektieren ... 348 Tipp 88 ... Layouts in Reportvarianten voreinstellen ... 351 Tipp 89 ... Eigene ALV-Reports mit dem QuickViewer anlegen ... 354 Tipp 90 ... ALV-Reports mit dem QuickViewer ausführen ... 360 Tipp 91 ... Tabellen für ALV-Auswertungen finden ... 363 TEIL 11. Druck und Download ... 369 Tipp 92 ... Schnelle Hardcopy erstellen ... 370 Tipp 93 ... Zentrale Voreinstellungen in den Benutzervorgaben vornehmen ... 372 Tipp 94 ... Probleme beim Ausdruck vermeiden ... 375 Tipp 95 ... Spool-Aufträge zur schnellen Recherche nutzen ... 381 Tipp 96 ... Download-Funktionen finden ... 386 Tipp 97 ... Frei wählbare Tabellenteile downloaden ... 388 TEIL 12. Abläufe mithilfe von Jobs automatisieren ... 391 Tipp 98 ... Langläufer mit Job durchführen ... 392 Tipp 99 ... Periodische Reports mit Jobs automatisch durchführen ... 397 Tipp 100 ... Reportliste aus Jobübersicht anzeigen ... 401 Tipp 101 ... Eigene Jobs überprüfen und abbrechen ... 403 Tipp 102 ... Eigene Jobs löschen ... 406 Tipp 103 ... Reportnamen finden ... 408 Tipp 104 ... Periodische Reports automatisch per E-Mail versenden ... 411 Tipp 105 ... Verteilerlisten anlegen ... 420 Tipp 106 ... Gemailten Report öffnen und bearbeiten ... 423 TEIL 13. Abläufe mithilfe von Skripting automatisieren ... 427 Tipp 107 ... Vorbereitung zum Erstellen von Skripten ... 428 Tipp 108 ... Kamera läuft! Ein Skript aufnehmen ... 430 Tipp 109 ... Film ab! Ein Skript abspielen ... 435 Tipp 110 ... Ein Skript als Favoriten speichern ... 438 Tipp 111 ... Ein Skript pflegen ... 440 Tipp 112 ... Und Tschüs ... schneller abmelden ... 442 Anhang ... 445 A ... Unsere Lieblings-Shortcuts ... 445 B ... Die Autoren ... 449 Index ... 453
Microservices mit Go
Microservices haben sich als eigenständige, aber zusammenhängende Dienste längst durchgesetzt und bieten eine flexible Alternative zu großen monolithischen Softwarearchitekturen. Mit dieser praxisorientierten Einführung steigen Sie direkt in die professionelle Programmierung von Microservices ein. Neben allen notwendigen Grundlagen des Architekturstils lernen Sie ganz nebenbei die beliebte Programmiersprache Go, wie Sie Microservices damit umsetzen und wie Sie Ihre Dienste gewinnbringend einsetzen. Aus dem Inhalt: Grundlagen von Go: Installation, Entwicklungsumgebungen, ToolsSprachgrundlagen: Variablen und Funktionen, Go Statements, Collections, PointerThird-Party-Libraries einbinden und eigene Module und Libraries entwickelnAlle Grundlagen über MicroservicesMicroservices mit Go umsetzenConcurreny: Nebenläufigkeit mit GoQualitätssicherung: Unit Test Framework und BenchmarkIdiomatic Go und Effective GoGo-Services in der Cloud betreiben Materialien zum Buch ... 9 Geleitwort des Fachgutachters ... 11 1. Einführung ... 13 1.1 ... Was sind Microservices? ... 13 1.2 ... Go -- Einführung und Geschichte ... 26 1.3 ... Warum eignet sich Go so gut für Microservices? ... 34 2. Die Grundlagen von Go ... 45 2.1 ... Installation ... 46 2.2 ... Sprachgrundlagen von Golang ... 89 2.3 ... Module und Libraries ... 135 3. Microservices ... 149 3.1 ... Grundlagen ... 152 3.2 ... Microservices mit Go ... 176 3.3 ... Go-Services im Microservice-Umfeld ... 223 3.4 ... Datenbankanbindung ... 256 3.5 ... Die Nebenläufigkeit mit Go -- Concurrency ... 296 4. Die Qualitätssicherung ... 309 4.1 ... Das Unit-Test Framework ... 310 4.2 ... Benchmarks für Go erstellen ... 318 4.3 ... Microservices testen und optimieren ... 320 5. Best Practices -- idiomatisches und effektives Go ... 331 5.1 ... Context-Package einsetzen ... 332 5.2 ... Error-Handling ... 340 5.3 ... Projekte sinnvoll organisieren ... 345 5.4 ... Code-Schnipsel und Tipps und Tricks ... 357 6. Go-Service an die Cloud anbinden ... 367 6.1 ... Deployment mit Docker und Kubernetes ... 368 6.2 ... Das Go Cloud Development Kit ... 383 6.3 ... Google Cloud Development ... 390 6.4 ... Amazon Web Services Deployment ... 397 6.5 ... Microsoft-Azure-Anbindung ... 402 Index ... 407
Android-Apps entwickeln mit Java
Ihr Einstieg in die App-Entwicklung mit Android Studio! Hier lernen Sie auf unterhaltsame Weise, wie Sie mit Java für Android entwickeln – z. B. ein eigenes Spiel mit allem Drum und Dran. Sie setzen Animationen, Sounds, Bewegungssensoren und die Kamera ein und erstellen schicke Layouts, Online-Bestenlisten und angesagte Features für die Smartwatch. Grundkenntnisse in der Programmierung werden vorausgesetzt – dann kann nichts mehr schief gehen auf dem Weg zur ersten Android-App! Aus dem Inhalt: StartvorbereitungenJava-Einführung direkt mit AndroidAndroid-Studio installierenSchritt für Schritt zur ersten AppEin Spiel entwickelnWas soll das Spiel machen? – Aufbau der Game EngineSound und Animation hinzufügenSpieler vernetzen: Highscores und BestenlistenAugmented Reality: mehr Spaß und Spannung durch die KameraNoch mehr Techniken!Arbeiten mit GeokoordinatenHintergrundservices nutzenEin neues Layout für Ihre AppSmartwatch anbindenApps veröffentlichen in Google Play und anderen Markets Vorwort ... 13 Materialien zum Buch ... 14 1. Einleitung ... 15 1.1 ... Für wen ist dieses Buch? ... 15 1.2 ... Unendliche Möglichkeiten ... 20 1.3 ... Was ist so toll an Android? ... 26 2. Ist Java nicht auch eine Insel? ... 39 2.1 ... Warum Java? ... 39 2.2 ... Grundlagen ... 42 2.3 ... Pakete ... 45 2.4 ... Klassen implementieren ... 48 2.5 ... Daten verwalten ... 60 2.6 ... Vererbung ... 63 3. Vorbereitungen ... 69 3.1 ... Was brauche ich, um zu beginnen? ... 69 3.2 ... Schritt 1: Android Studio installieren ... 71 3.3 ... Schritt 2: Das Android SDK ... 72 3.4 ... Ein neues App-Projekt anlegen ... 75 3.5 ... Android Studio mit dem Handy verbinden ... 78 3.6 ... Fehlersuche ... 80 4. Die erste App ... 89 4.1 ... Sag »Hallo«, Android! ... 89 4.2 ... Bestandteile einer Android-App ... 98 4.3 ... Benutzeroberflächen bauen ... 111 4.4 ... Buttons mit Funktion ... 122 4.5 ... Eine App installieren ... 126 5. Ein Spiel entwickeln ... 131 5.1 ... Wie viele Stechmücken kann man in einer Minute fangen? ... 131 5.2 ... Grafiken einbinden ... 138 5.3 ... Die Game Engine ... 142 5.4 ... Der erste Mückenfang ... 176 6. Sound und Animation ... 183 6.1 ... Sounds hinzufügen ... 184 6.2 ... Sounds abspielen ... 187 6.3 ... Einfache Animationen ... 191 6.4 ... Fliegende Mücken ... 203 7. Internetzugriff ... 217 7.1 ... Highscores speichern ... 217 7.2 ... Bestenliste im Internet ... 227 7.3 ... Listen mit Adaptern ... 239 8. Kamera und Augmented Reality ... 249 8.1 ... Die Kamera verwenden ... 249 8.2 ... Bilddaten verwenden ... 261 9. Sensoren und der Rest der Welt ... 271 9.1 ... Himmels- und sonstige Richtungen ... 271 9.2 ... Wo fliegen sie denn? ... 279 9.3 ... Beschleunigung und Erschütterungen ... 294 9.4 ... Hintergrund-Services ... 302 9.5 ... Arbeiten mit Geokoordinaten ... 309 10. Smartwatch und Android Wear ... 321 10.1 ... Welt am Handgelenk ... 321 10.2 ... Phone ruft Uhr ... 323 10.3 ... Ein Wear-Projekt ... 327 10.4 ... Uhr ruft Phone ... 330 10.5 ... Wear 2.x ... 335 10.6 ... Fazit ... 339 11. Tipps und Tricks ... 341 11.1 ... Views mit Stil ... 341 11.2 ... Dialoge ... 351 11.3 ... Layout-Gefummel ... 360 11.4 ... Teilen und Empfangen ... 371 11.5 ... Daten speichern leicht gemacht ... 381 11.6 ... Öffentliche Webservices abfragen ... 388 11.7 ... Activities aus Fragmenten ... 398 12. Apps veröffentlichen ... 405 12.1 ... Vorarbeiten ... 405 12.2 ... Hausaufgaben ... 411 12.3 ... Alternative Markets ... 424 Index ... 433
Einstieg in Data Science mit R
Datenanalyse ist überall angekommen – seien auch Sie dabei! Quereinsteiger wie Historiker oder Germanisten, die mit quantitativen Methoden beginnen möchten, sind bei diesem Buch richtig, ob für die Forschung oder im Unternehmen. Sie bekommen alles an die Hand, was Sie zum Loslegen brauchen. Lassen Sie Excel-Tabellen hinter sich und lernen Sie, wie Sie statistische Analysen mit R programmieren. Auch die mathematischen Grundlagen lernen Sie kennen, von den Mittelwerten bis zur linearen Regression. Nach der Lektüre sind Sie in der Lage, ein eigenes Projekt mit ausgewählten statistischen Methoden durchzuführen und Ihre Ergebnisse zu visualisieren. Aus dem Inhalt: InstallationProgrammieren für QuereinsteigerDaten verschiedener Formate ladenDaten bereinigenMit fehlenden Werten umgehenWachstumsberechnungenMittelwerteLineare RegressionR StudioEinstieg in die Programmiersprache R Materialien zum Buch ... 11 1. Über dieses Buch ... 13 1.1 ... Für wen ist dieses Buch? Für Sie? ... 13 1.2 ... Was sind die Ziele, was können Sie hier lernen? ... 13 1.3 ... Was Sie nicht lernen werden ... 15 1.4 ... Wie Sie mit diesem Buch arbeiten ... 17 2. Einführung ... 19 2.1 ... Statistik und Data Science im Vergleich ... 21 2.2 ... Was ist R, und warum sollten Sie das überhaupt lernen? ... 23 3. R Base und RStudio: Installation und erste Schritte ... 25 3.1 ... R Base ... 25 3.2 ... RStudio ... 29 3.3 ... Wie sieht die Oberfläche aus, und was bedeuten die einzelnen Bereiche? ... 31 3.4 ... Die R-Konsole ... 33 3.5 ... Mein erstes Skript ... 35 3.6 ... Hilfe! ... 42 4. Die Programmiersprache R ... 51 4.1 ... Objekte ... 51 4.2 ... Funktionen ... 52 4.3 ... Pakete (Packages) ... 53 4.4 ... Ein paar Vokabeln ... 61 4.5 ... Kommentare ... 68 4.6 ... Groß- und Kleinschreibung und andere Syntaxregeln ... 68 4.7 ... Computer sind dumm ... 71 5. Grundlagen der statistischen Datenanalyse ... 73 5.1 ... Fragestellung und Studiendesign ... 73 5.2 ... Von Daten und Datensätzen ... 74 5.3 ... Berechnung des Durchschnittswertes (Mittelwert, arithmetisches Mittel) ... 84 5.4 ... Wachstumsberechnung (Veränderungsberechnung) ... 84 5.5 ... Trend und lineare Regression ... 86 5.6 ... Beispieldatensatz »Zigarettenverbrauch« ... 88 6. Daten einlesen und für die Analyse vorbereiten ... 93 6.1 ... Daten aus Excel einlesen ... 93 6.2 ... Daten im .csv-Format einlesen ... 98 6.3 ... Umgang mit Datumsangaben ... 102 6.4 ... Daten vorbereiten ... 109 6.5 ... Not available! - Der Umgang mit fehlenden Werten ... 122 7. Daten analysieren mit einfacher Statistik ... 129 7.1 ... Beispiel 1: Zigarettenkonsum ... 129 7.2 ... Beispiel 2: 100 Jahre Wohlstandsentwicklungen in Indien ... 144 7.3 ... Visualisierung ... 166 8. Umfassendes Praxisbeispiel ... 187 8.1 ... Fragestellung: Was will ich wissen? ... 188 8.2 ... Datenbeschaffung ... 189 8.3 ... Daten laden und Überblick verschaffen ... 191 8.4 ... Daten vorbereiten und bereinigen ... 195 8.5 ... Verarbeitung der Daten im Dreiklang ... 196 8.6 ... Kommunikation ... 219 8.7 ... Dokumentation ... 219 8.8 ... Bonus: Folgeanalyse in der Zeitreihe: Krankheitstage ... 219 9. Abschluss ... 233 A. Datenmaterial ... 235 A.1 ... Zigaretten 1 ... 235 A.2 ... Zensus Länder ... 236 A.3 ... Luftqualität ... 237 A.4 ... Zigaretten 2 ... 243 A.5 ... Indien 1990-2000 ... 244 A.6 ... Personaldaten ... 245 A.7 ... Personaldaten - Erweitert ... 252 Index ... 261
Microsoft Access für Einsteiger
Mit Microsoft Access können Sie ganz leicht alle Ihre Daten verwalten: sei es für die Mediensammlung daheim, für das Studium, für das eigene Unternehmen oder für den Verein. Wie das geht, zeigt Ihnen dieses Buch. Vorkenntnisse benötigen Sie keine. Sie lernen, wie man Datenbanken modelliert, wie Access-Datenbanken entwickelt werden und wie Sie mit Makros Datenbanken leicht an Ihre Bedürfnisse anpassen. An sechs umfassenden Beispieldatenbanken aus den Bereichen Handel, Handwerk, Medien und Vermietung testen Sie Ihre Kenntnisse. Aus dem Inhalt: Access kennenlernen: eine fertige Datenbank benutzenDatenmodellierung: eine eigene Datenbank entwerfenTabellen, Abfragen, Formulare, Berichte erstellenDaten importieren und exportierenDatenbanken individualisieren mit MakrosTools zur Analyse und Optimierung Materialien zum Buch ... 17 1. Einführung ... 19 1.1 ... Was macht eine Datenbank? ... 19 1.2 ... Entwickler und Benutzer ... 20 1.3 ... Warum sollten Sie mit Datenbanken arbeiten? ... 20 1.4 ... Wer sollte dieses Buch lesen? ... 21 1.5 ... Wie sind relationale Datenbanken aufgebaut? ... 22 2. Eine fertige Anwendung benutzen ... 29 2.1 ... Die Benutzung ermöglichen ... 29 2.2 ... Eine Vorstellung der Möglichkeiten ... 30 2.3 ... Der Aufbau dieser Anwendung ... 43 3. Eigene Datenbanken modellieren ... 53 3.1 ... Eine einfache Kundendatenbank ... 53 3.2 ... Der Ausbau der Handelsanwendung ... 59 3.3 ... Die Verwaltung von Medien ... 68 4. Eine einfache Anwendung realisieren ... 77 4.1 ... Ziel dieses Kapitels ... 77 4.2 ... Eine Datenbank erzeugen ... 79 4.3 ... Die Oberfläche von MS Access ... 80 4.4 ... Eine einzelne Tabelle anlegen ... 81 4.5 ... Die ersten Daten eingeben ... 91 4.6 ... Formulare zur Bedienung nutzen ... 96 4.7 ... Berichte zur Präsentation erstellen ... 115 5. Eine komplexe Anwendung realisieren ... 123 5.1 ... Ziel dieses Kapitels ... 123 5.2 ... Datenbank und Tabellen anlegen ... 125 5.3 ... Beziehungen erstellen ... 130 5.4 ... Formulare über mehrere Tabellen ... 135 5.5 ... Berichte über mehrere Tabellen ... 167 6. Abfragen ... 179 6.1 ... Aufbau ... 179 6.2 ... Sortieren ... 186 6.3 ... Filtern ... 190 6.4 ... Verknüpfte Kriterien ... 202 6.5 ... Besondere Abfragen ... 208 6.6 ... Berechnungen ... 216 6.7 ... Integrierte Funktionen ... 224 6.8 ... Abfragen über mehrere Tabellen ... 236 6.9 ... Gruppierungen ... 247 6.10 ... Gruppierungen und Berechnungen ... 254 6.11 ... Berechnungen von Zeiten und Kosten ... 262 6.12 ... Joins ... 269 6.13 ... Aktionsabfragen ... 272 7. Objekte, Datenbanken, Tabellen ... 279 7.1 ... Objekte in MS Access ... 279 7.2 ... Assistenten und Vorlagen ... 283 7.3 ... Vorlagen für Datenbanken ... 284 7.4 ... Tabellen ... 286 7.5 ... Aufbau einer Anwendung ... 288 8. Formulare ... 293 8.1 ... Ansichten ... 293 8.2 ... Darstellungsformen ... 296 8.3 ... Vorlagen ... 298 8.4 ... Formular-Assistent ... 306 9. Steuerelemente ... 317 9.1 ... Bezeichnungsfeld ... 317 9.2 ... Textfeld ... 319 9.3 ... Listenfeld ... 322 9.4 ... Schaltfläche ... 330 9.5 ... Makros ändern ... 338 9.6 ... Kombinationsfeld ... 340 9.7 ... Unterformular ... 347 10. Berichte ... 355 10.1 ... Ansichten ... 356 10.2 ... Vorlagen ... 358 10.3 ... Berichts-Assistent ... 361 11. Externe Daten ... 373 11.1 ... Importieren und Verknüpfen ... 373 11.2 ... Exportieren ... 386 11.3 ... Gespeicherte Im- und Exporte ... 392 12. Werkzeuge ... 393 12.1 ... Werkzeuge zur Optimierung ... 393 12.2 ... Werkzeuge zur Analyse ... 397 Anhang ... 401 A ... Lösung der Übungsaufgaben ... 401 Index ... 431
Anwendungsentwicklung auf der SAP Cloud Platform
Ob Erweiterungen für SAP-Cloud-Lösungen oder eigenständige Anwendungen auf der SAP Cloud Platform (SAP BTP) – dieses Buch macht Ihnen die Entwicklung leicht! Klaus Kopecz zeigt Ihnen, wie Sie mit dem SAP Cloud Application Programming Model (CAPM) im Handumdrehen Ihre erste eigene Cloud-Anwendung erstellen. Von der Anlage des Daten- und Servicemodells bis zur produktiven Anwendung werden Sie durch alle erforderlichen Schritte geführt. Aus dem Inhalt: Was ist das SAP Cloud Application Programming Model (CAP)?Entwicklung in Visual Studio CodeDaten- und Servicemodellierung mit CDSEreignisbehandlerroutinen mit Node.jsAnbindung von SAP-Fiori-OberflächenGlobalisierungAuthentifizierung und AutorisierungApplication Programming Interfaces (APIs)Deployment auf der SAP Cloud PlatformZugriff auf SAP HANA und andere Services der SAP Cloud Platform Einleitung ... 17 TEIL I Einführung ... 25 1. Einführung in das SAP Cloud Application Programming Model ... 27 1.1 ... Die SAP Cloud Platform ... 28 1.2 ... Was ist das SAP Cloud Application Programming Model? ... 31 1.3 ... Nächste Schritte ... 44 2. Erste Schritte zur eigenen Anwendung ... 45 2.1 ... Aufbau einer lokalen Entwicklungsumgebung ... 46 2.2 ... CDS-Editor ... 60 2.3 ... »Hallo CAP«-Service ... 62 2.4 ... CDS Command Line Interface ... 72 2.5 ... Was sollten Sie aus diesem Kapitel mitnehmen? ... 74 TEIL II Anwendungsentwicklung ... 77 3. Start des Entwicklungsprojekts ... 79 3.1 ... Modell eines Produktkatalogs ... 79 3.2 ... Entwicklungsprojekt anlegen ... 82 3.3 ... Domänenmodell anlegen ... 86 3.4 ... Die Serviceschicht ... 89 3.5 ... Datenabfragen ... 92 3.6 ... Testen mit einem HTTP-Client ... 94 3.7 ... Debuggen einer Service-Implementierung ... 103 3.8 ... Was sollten Sie aus diesem Kapitel mitnehmen? ... 108 4. Core Data Services für CAP im Detail ... 111 4.1 ... CDS als Familie von Modellierungssprachen ... 112 4.2 ... Entitäten und Views ... 116 4.3 ... Assoziationen und Kompositionen ... 119 4.4 ... Typen in CDS ... 122 4.5 ... Weitere Eigenschaften von Elementen ... 126 4.6 ... Die CDS Query Language ... 126 4.7 ... Namensräume ... 131 4.8 ... Referenzen auf Modelle ... 132 4.9 ... Annotationen ... 135 4.10 ... Services ... 143 4.11 ... Aspekte ... 148 4.12 ... Lokalisierung ... 151 4.13 ... Lokalisierte Daten ... 156 5. Weiterentwicklung zur produktiven Anwendung ... 159 5.1 ... Wiederverwendung von Typen und Aspekten ... 160 5.2 ... Implementierung der Rolle des Katalognutzers ... 169 5.3 ... Konfiguration ... 174 5.4 ... Authentifizierung und Autorisierung ... 185 5.5 ... Entwurf eines UIs mit SAP Fiori Elements ... 194 5.6 ... Was sollten Sie aus diesem Kapitel mitnehmen? ... 205 6. Das CDS API für Node.js ... 209 6.1 ... CAP-Laufzeit = Services + Events ... 210 6.2 ... Exponieren von Services ... 212 6.3 ... Behandeln von Ereignissen ... 214 6.4 ... Konnektivität zu Services ... 218 6.5 ... Konsumieren von Services ... 220 6.6 ... Das Request-Objekt ... 223 6.7 ... Konstruktion von CQN-Objekten ... 226 6.8 ... Modellverarbeitung ... 228 TEIL III Deployment auf die SAP Cloud Platform ... 231 7. Deployment-Umgebung auf der SAP Cloud Platform anlegen ... 233 7.1 ... Anlegen eines Trial-Accounts ... 235 7.2 ... Subaccounts mit Cloud-Foundry-Umgebung ... 238 7.3 ... Einführung in die Arbeit mit Cloud Foundry ... 241 7.4 ... Deployment einer Cloud-Foundry-Applikation ... 248 7.5 ... Was sollten Sie aus diesem Kapitel mitnehmen? ... 261 8. SAP-Anwendungsarchitektur in der Cloud-Foundry-Umgebung ... 263 8.1 ... Geschäftsanwendung als Summe spezialisierter Services ... 264 8.2 ... Authorization and Trust Management ... 268 8.3 ... Application Router ... 271 8.4 ... Webserver für das SAP-Fiori-UI ... 279 8.5 ... Was haben Sie in diesem Kapitel erreicht? ... 287 9. Anbindung an SAP HANA ... 289 9.1 ... SAP-HANA-Datenbankinstanz anlegen ... 291 9.2 ... Anbindung von SAP HANA an die lokale Entwicklungsumgebung ... 294 9.3 ... SAP HANA Deployment Infrastructure ... 304 10. Hybride Entwicklung ... 311 10.1 ... Die Technik der hybriden Entwicklung ... 313 10.2 ... Anbindung des lokalen CAP-Servers an SAP HANA ... 317 10.3 ... Authorization and Trust Management Service konfigurieren und anbinden ... 318 10.4 ... Was Sie in diesem Kapitel erreicht haben ... 333 11. Deployment der Geschäftsanwendung ... 335 11.1 ... Der CAP-Build-Prozess ... 336 11.2 ... Deployment mittels Cloud-Foundry-Manifest ... 341 11.3 ... Deployment als Multitarget Application ... 349 11.4 ... Was Sie in diesem Kapitel erreicht haben ... 366 TEIL IV Integration mit SAP-Produkten und -Services ... 367 12. Das SAP Business Application Studio ... 369 12.1 ... Vor der Nutzung ... 371 12.2 ... CAP im SAP Business Application Studio ... 377 12.3 ... Was Sie aus diesem Kapitel mitnehmen sollten ... 381 13. Integration mit SAP-Lösungen ... 383 13.1 ... SAP Cloud Platform Connectivity ... 384 13.2 ... SAP Cloud Platform Enterprise Messaging ... 386 13.3 ... Externe Services an eine CAP-Anwendung anbinden ... 388 13.4 ... Ereignisse senden und verarbeiten mit CAP ... 397 13.5 ... Was sollten Sie aus diesem Kapitel mitnehmen? ... 401 14. Problembehandlung ... 403 14.1 ... Installieren von npm-Paketen schlägt fehl ... 403 14.2 ... »cds compile« erzeugt nicht verarbeitbare Dateien ... 405 14.3 ... Debugging ... 405 14.4 ... Senden von HTTP-Requests ... 406 14.5 ... Arbeiten mit SAP HANA ... 406 14.6 ... Aufruf des SAP-Fiori-UI ... 407 15. Zusammenfassung und Ausblick ... 409 Linksammlung ... 413 Der Autor ... 417 Index ... 419
Traefik API Gateway for Microservices
Use Traefik as a load balancer or a reverse proxy for microservices-based architecture. This book covers Traefik integration for microservices architecture concerns such as service discovery, telemetry, and resiliency.The book focuses on building an in-depth understanding of Traefik. It starts with the fundamentals of Traefik, including different load balancing algorithms available, and failure handling for application resiliency. Examples are included for the failure scenarios. TLS support is explained, including scenarios of TLS termination and TLS forwarding. Traefik supports TLS termination using Let's Encrypt. Traefik deployment in prominent microservices ecosystems is discussed, including Docker and Kubernetes.Traefik is a language-neutral component. This book presents examples of its deployment with Java-based microservices. The examples in the book show Traefik integration with Jaeger/Zipkin, Prometheus, Grafana, and FluentD. Also covered is Traefik for Python-based services and Java-based services deployed in the Kubernetes cluster. By the end of the book, you will confidently know how to deploy and integrate Traefik into prominent microservices ecosystems.WHAT YOU WILL LEARN* Understand Traefik basics and its components* Explore different load balancing scenarios and TLS termination* Configure service discovery, circuit breakers, timeouts, and throttling* Monitor Traefik using Prometheus and request tracingWHO THIS BOOK IS FORDevelopers and project managers who have developed microservices and are deploying them in cloud and on-premise environments with Kubernetes or Docker. The book is not specifically written for any particular programming language. The examples presented use Java or Python.RAHUL SHARMA is a seasoned Java developer with over 15 years of industry experience. In his career he has worked with companies of various sizes from enterprises to startups. During this time he has developed and managed microservices on the cloud (AWS/GCE/DigitalOcean) using open source software. He is an open source enthusiast and shares his experience at local meetups. He co-authored Java Unit Testing with JUnit 5 (Apress) and Getting Started with Istio Service Mesh (Apress).AKSHAY MATHUR is a software engineer with 15 years of experience, mostly in Java and web technologies. Most of his career has been spent building B2B platforms for enterprises, dealing with concerns such as scalability, configurability, multi-tenancy, and cloud engineering. He has hands-on experience implementing and operating microservices and Kubernetes in these ecosystems. Currently, he enjoys public speaking and blogging on new cloud native technologies (especially plain Kubernetes) and effective engineering culture.Chapter 1: Introduction to TraefikCHAPTER GOAL: THE CHAPTER COVERS THE NEED OF A BETTER LOAD BALANCER USING MICROSERVICES COMPONENTS. IT COVERS TRAEFIK COMPONENTS AND BUILD THE BASIC UNDERSTANDING. THE READER WILL SETUP THE ENVIRONMENT WHICH WILL GET STARTED WITH TRAEFIKNO OF PAGES: 20SUB -TOPICS1. Monolith to microservices architecture evolution1. Static configuration challenges2. Observability challenges3. TLS as identity2. Traefik components1. CLI2. DashboardChapter 2: Configure TraefikCHAPTER GOAL: THE CHAPTER WILL COVER ROUTING BASICS. IT WILL DISCUSS THE VARIOUS COMPONENTS.NO OF PAGES: 20SUB - TOPICS1. Entrypoint2. Routers3. ServicesChapter 3: Load Balancing and Failure DetectionCHAPTER GOAL: THE CHAPTER WILL COVER DIFFERENT LOAD BALANCING OPTIONS AVAILABLE IN TRAEFIK.NO OF PAGES : 30SUB - TOPICS:1. Configuring HTTP servicea. Round robinb. Weighted round robinc. Mirroringd. Health checks2. Configuring TCP servicea. Round robinb. Weighted round robinChapter 4: Configure TLSCHAPTER GOAL: TLS IS AN IMPORTANT PART OF LOAD BALANCING. WE WILL COVER HOW TO DO TLS TERMINATION AND TLS PASS THROUGH USING TRAEFIK.NO OF PAGES: 15SUB - TOPICS:1. Configure TLS terminationa. Using lets encrypt2. Configure TLS pass-throughChapter 5: Logs, Request Tracing and Black ListingCHAPTER GOAL: THE CHAPTER WILL COVER OBSERVABILITY FEATURES OF TRAEFIKNO OF PAGES: 30SUB - TOPICS:1. Trafik logging2. Access logs3. Request tracing4. IP blacklisting5. MetricesChapter 6: Traefik as MicroservicesCHAPTER GOAL: THE CHAPTER WILL USE TRAEFIK FOR MICROSERVICES TRAFFIC ROUTING. IT WILL LOAD CONFIGURATION AND DISCOVER SERVICES FROM A BACKEND. IT WILL CONFIGURE CIRCUIT BREAKERS, THROTTLING AND RETRIES.NO OF PAGES: 30SUB - TOPICS:1. Routing using service discovery2. configure circuit breakers and retries3. configure throttling4. Supporting canary routesChapter 7: Traefik as Kubernetes IngressCHAPTER GOAL: THE CHAPTER WILL SETUP TRAEFIK AS KUBERNETES INGRESS. IT WILL SETUP MUTUAL TLS AUTHENTICATION FOR IDENTITY AND ROLE BASED ACCESS CONTROL. IT WILL SEND METRICES AND TRACING TO PROMETHEUS AND JAGGER K8S COMPONENTS.NO OF PAGES: 30SUB - TOPICS:1. Configure Kubernetes ingress2. Enable mTLS authenticationa. configure RBAC3. Configure TLS termination for user requests4. Configure request tracing with Jaeger5. Capture metrices in prometheus
Become ITIL® 4 Foundation Certified in 7 Days
Use this guide book in its fully updated second edition to study for the ITIL 4 Foundation certification exam. Know the latest ITIL framework and DevOps concepts.The book will take you through the new ITIL framework and nuances of the DevOps methodology. The book follows the topics included in the foundation certification exam syllabus and includes new sections on ITIL's guiding principles, service value chain, and the four dimensions of service management. Also included are the concepts, processes, and philosophies used in DevOps programs and projects. ITIL and DevOps concepts are explained with relevant examples.By the time you finish this book, you will have a complete understanding of ITIL 4 and will be ready to take the ITIL 4 Foundation certification exam. You will know the DevOps methodology and how ITIL reinforces the philosophy of shared responsibility and collaboration. Over the course of a week, even while working your day job, you will be prepared to take the exam.WHAT YOU WILL LEARN* Know the basics of ITIL as you prepare for the ITIL Foundation certification exam* Understand ITIL through examples* Be aware of ITIL's relevance to DevOps and DevOps conceptsWHO THIS BOOK IS FORProfessionals from the IT services industryABHINAV KRISHNA KAISER works as a senior manager at a top consulting firm. He consults with organizations to assess, define, and implement DevOps, Agile, and ITIL processes. Abhinav is an accredited ITIL trainer and has delivered numerous classroom trainings. He is a leading authority on the topics of DevOps, Agile, and ITIL. He lives in London, United Kingdom. He is an author and his latest book is Reinventing ITIL in the Age of DevOps (Apress).Chapter 1: Introduction to the new ITILChapter Goal: To introduce the new ITIL, provide context and differentiate with the version 3No of pages : 15 pagesSub -Topics1. Why ITIL 4?1. Difference between ITIL 3 and ITIL 42. ITIL 4 Foundation Exam3. Other ITIL 4 ExamsChapter 2: Brief Overview of DevOpsChapter Goal: To introduce the DevOps frameworkNo of pages : 20 pagesSub -Topics1. Introduction to DevOps2. DevOps sections – people, process and technology3. DevOps processesChapter 3: ITIL BasicsChapter Goal: To introduce the key concepts of ITILNo of pages : 20 pagesSub -Topics1. Defining value2. Products vs services3. Concept of consumers and other stakeholders4. service relationships5. Processes and functionsChapter 4: Service Management - Four DimensionsChapter Goal: To discuss the four dimensions in detailNo of pages: 20 pagesSub - Topics1. Organizations and people2. Information and technology3. Partners and suppliers4. Value Streams and processesChapter 5: ITIL Service Value SystemChapter Goal: To introduce service value systemNo of pages : 20 pagesSub - Topics:1. Intro to service value system2. Opportunity and demand3. Service value chain4. Governance5. Continual Improvement (formerly CSI)Chapter 6: ITIL Processes for Managing StakeholdersChapter Goal: Understand the processes for managing customers and other key stakeholdresNo of pages: 15 pagesSub - Topics:1. Relationship management2. Service level management3. Supplier managementChapter 7: ITIL Processes for Defining Operations FrameworkChapter Goal: Understand the processes for defining processes that sets the boundaries and steps for support and operational activitiesNo of pages: 30 pagesSub - Topics:1. Service configuration management2. IT asset management3. Information security management4. Continual improvementChapter 8: ITIL Processes for Managing OperationsChapter Goal: Understand the processes in detail for managing operationsNo of pages: 30 pagesSub - Topics:1. Monitoring and event management2. Incident management3. Problem improvement4. Change controlChapter 9: ITIL Processes for Managing ChangesChapter Goal: Understand the processes for controlling changes to the environment and applicationsNo of pages: 20 pagesSub - Topics:1. Service request management2. Change control3. Release managementChapter 10: ITIL Practice for Managing DeploymentsChapter Goal: Understand the technical management around deploying software into environmentsNo of pages: 15 pagesSub - Topics:1. Deployment managementChapter 11: ITIL Practice for Coordinating between StakeholdersChapter Goal: Understand the service desk and service desk managementNo of pages: 15 pagesSub - Topics:1. Service desk2. Service desk managementChapter 12 : Practices to Manage DeploymentsRelease ManagementTypes of ReleasesEngagement with Service Value ChainDeployment ManagementKey ActivitiesEngagement with Service Value ChainChapter 13 : Practices to Coordinate with StakeholdersService DeskTypes of Service DesksKey ActivitiesEngagement with Service Value ChainService Desk ManagementEngagement with Service Value ChainChapter 14 : Exam Tips and Tricks
Interaktive Datenvisualisierung in Wissenschaft und Unternehmenspraxis
Interaktive Visualisierungen gewinnen in Wissenschaft und Unternehmenspraxis zunehmend an Bedeutung. Neben der Analyse und Darstellung von Unternehmensdaten z.B. mit Hilfe moderner Data Science Methoden werden auch Visualisierungen und Animationen mit Hilfe von 3D und Virtual Reality/Augmented Reality Technologien immer wichtiger, etwa bei der Planung von Industrieanlagen, in der Architektur oder bei der Darstellung naturwissenschaftlicher Prozesse.Das vorliegende praxisorientierte Herausgeberwerk basiert auf Ergebnissen, die im Kontext der Tagung VISUALIZE an der Hochschule Rhein-Waal vorgestellt wurden und umfasst Beiträge unterschiedlicher Visualisierungsdomänen, darunter auch Business Intelligence Lösungen mit Qlik Sense, R, Shiny und Python. Die Visualisierungstechniken und konkreten Methoden aus begleitenden Workshops werden zu anwendungsnahen Handlungsempfehlungen und Best Practices für eigene Visualisierungsvorhaben zusammengefasst.Ein Buch für alle, die auf der Suche nach konkreten Handlungsempfehlungen und Praxisbeispielen zur interaktiven Datenvisualisierung sind.Dr. Timo Kahl ist Professor für Wirtschaftsinformatik an der Hochschule Rhein-Waal und leitet den Studiengang und das Labor für E-Government. Seine fachlichen Schwerpunkte liegen in den Bereichen Prozessmanagement, Verwaltungsmodernisierung, Business Integration und Business Intelligence.Dr. Frank Zimmer ist Professor für Informatik und Mathematik an der Hochschule Rhein-Waal und leitet das Labor für Computational Intelligence und Visualisierung. Seine fachlichen Schwerpunkte sind Maschinelles Lernen, Data Science, Simulationen und Visualisierung.Visualisierungen in 3D Anwendungen.-Visualisierungskonzepte und moderne Werkzeuge (Qlik Sense, R, Shiny, Python, Houdini, Unity, Unreal & Co.).-Prozess- und Datenvisualisierung.-Visualisierung im Kontext von Machine Learning.