This document provides an overview of tools and concepts for using C++, including:
- Compiling and linking code by splitting classes into header and source files.
- Static vs dynamic libraries and how they are included in programs.
- Setting up include and library paths to import the Box2D physics library into a C++ project.
- Popular C++ libraries like Boost, GUI frameworks like Qt and SDL, and game engines like Unity and Unreal that can be used in C++ projects.
- Tips for using debugging tools, documentation tools like Doxygen, and build systems like CMake in C++ development.
This document summarizes the London Dart Hackathon. It discusses that Dart is a programming language designed for complex applications and team development. It is easily compilable to JavaScript. The document provides examples of Dart code showing functions, classes, interfaces, libraries, and optional typing. It also discusses Dart libraries for HTML, JSON, and server-side IO. In conclusion, it encourages trying Dart and provides links for more information.
This document provides an overview of the Dart programming language. It discusses why Dart was created by Google, its key design goals around flexibility, familiarity, and performance. It also summarizes Dart's main features like optional typing, classes and interfaces, libraries, and futures. The document encourages attendees to get involved in the technical preview by visiting the Dart website, joining mailing lists, and using online resources.
This document provides an overview of the Dart programming language. Dart is a language and tool ecosystem for building complex web apps in teams. It runs in the browser and on servers. Key points covered include: Dart is optionally typed and runs in a virtual machine; the goals of Dart including performance, familiarity, and flexibility; and libraries like dart:html for DOM manipulation and dart:io for server-side functionality. The presentation encourages attendees to get involved in the technical preview to help shape the future of Dart.
The document discusses C++ and its evolution over time. Some key points include:
- C++ has been active for over 30 years and remains relevant due to its performance and use in applications like mobile.
- The new C++11 standard adds many new features that make the language more powerful yet easier to use, such as rvalue references, lambdas, and type inference.
- Examples are provided showing how new C++11 features like futures, lambdas and static assertions can be used concisely to solve common programming problems in a more modern style.
An introduction to Rust: the modern programming language to develop safe and ...Claudio Capobianco
Rust is a young programming language developed by Mozilla with the open source community support. According to a survey of StackOverflow, in 2016 was the most loved among developers language! The goal of Rust is to combine control and performances, that is, operate at low level with high-level constructs. The actual applications vary from operating system to web development. Rust natively includes tools for Agile development, such as dependency management, testing and much more. The gap with other popular languages is filling up quickly thanks to the community, very active and fantastic :)
In this introductory presentation we will discuss the characteristics that make Rust unique, including the concepts of Ownership, Borrowing, and Lifetimes.
These slide has be presented for a talk in BIC Lazio Casilina, that has been also the first meetup of Rust Rome!
This document discusses Scoobi, a Scala library for developing MapReduce applications on Hadoop. Some key points:
1) Scoobi allows developers to write Hadoop MapReduce jobs using a functional programming style in Scala, inspired by Google's FlumeJava. It provides abstractions like DList and DObject to represent distributed datasets and computations.
2) Under the hood, Scoobi compiles Scala code into Java MapReduce jobs that run on Hadoop. It handles partitioning, parallelization, and distribution of data and computation across clusters.
3) Examples show how common operations like filtering, mapping, reducing can be expressed concisely using the Scoobi API, mirroring Scala
This document discusses using Gradle for building projects in multiple languages. Gradle's domain specific language is based on Groovy, which allows for concise syntax. Gradle supports building Java, C++, Ruby, and other languages through plugins. It can also be used to build documentation and publish artifacts to repositories. Migrating from other build systems like Ant, Maven, and Make to Gradle is also discussed.
The document appears to be an assignment submission for a Java programming class. It includes 18 programs covering various Java concepts like inheritance, interfaces, threads, exceptions, file handling and more. For each program, the code is listed along with sample output when run. The programs are meant to demonstrate the student's understanding of core Java topics.
This document summarizes the London Dart Hackathon. It discusses that Dart is a programming language designed for complex applications and team development. It is easily compilable to JavaScript. The document provides examples of Dart code showing functions, classes, interfaces, libraries, and optional typing. It also discusses Dart libraries for HTML, JSON, and server-side IO. In conclusion, it encourages trying Dart and provides links for more information.
This document provides an overview of the Dart programming language. It discusses why Dart was created by Google, its key design goals around flexibility, familiarity, and performance. It also summarizes Dart's main features like optional typing, classes and interfaces, libraries, and futures. The document encourages attendees to get involved in the technical preview by visiting the Dart website, joining mailing lists, and using online resources.
This document provides an overview of the Dart programming language. Dart is a language and tool ecosystem for building complex web apps in teams. It runs in the browser and on servers. Key points covered include: Dart is optionally typed and runs in a virtual machine; the goals of Dart including performance, familiarity, and flexibility; and libraries like dart:html for DOM manipulation and dart:io for server-side functionality. The presentation encourages attendees to get involved in the technical preview to help shape the future of Dart.
The document discusses C++ and its evolution over time. Some key points include:
- C++ has been active for over 30 years and remains relevant due to its performance and use in applications like mobile.
- The new C++11 standard adds many new features that make the language more powerful yet easier to use, such as rvalue references, lambdas, and type inference.
- Examples are provided showing how new C++11 features like futures, lambdas and static assertions can be used concisely to solve common programming problems in a more modern style.
An introduction to Rust: the modern programming language to develop safe and ...Claudio Capobianco
Rust is a young programming language developed by Mozilla with the open source community support. According to a survey of StackOverflow, in 2016 was the most loved among developers language! The goal of Rust is to combine control and performances, that is, operate at low level with high-level constructs. The actual applications vary from operating system to web development. Rust natively includes tools for Agile development, such as dependency management, testing and much more. The gap with other popular languages is filling up quickly thanks to the community, very active and fantastic :)
In this introductory presentation we will discuss the characteristics that make Rust unique, including the concepts of Ownership, Borrowing, and Lifetimes.
These slide has be presented for a talk in BIC Lazio Casilina, that has been also the first meetup of Rust Rome!
This document discusses Scoobi, a Scala library for developing MapReduce applications on Hadoop. Some key points:
1) Scoobi allows developers to write Hadoop MapReduce jobs using a functional programming style in Scala, inspired by Google's FlumeJava. It provides abstractions like DList and DObject to represent distributed datasets and computations.
2) Under the hood, Scoobi compiles Scala code into Java MapReduce jobs that run on Hadoop. It handles partitioning, parallelization, and distribution of data and computation across clusters.
3) Examples show how common operations like filtering, mapping, reducing can be expressed concisely using the Scoobi API, mirroring Scala
This document discusses using Gradle for building projects in multiple languages. Gradle's domain specific language is based on Groovy, which allows for concise syntax. Gradle supports building Java, C++, Ruby, and other languages through plugins. It can also be used to build documentation and publish artifacts to repositories. Migrating from other build systems like Ant, Maven, and Make to Gradle is also discussed.
The document appears to be an assignment submission for a Java programming class. It includes 18 programs covering various Java concepts like inheritance, interfaces, threads, exceptions, file handling and more. For each program, the code is listed along with sample output when run. The programs are meant to demonstrate the student's understanding of core Java topics.
Dean Wampler presents on using Scalding, which leverages Cascading, to write MapReduce jobs in a more productive way. Cascading provides higher-level abstractions for building data pipelines and hides much of the boilerplate of the Hadoop MapReduce framework. It allows expressing jobs using concepts like joins and group-bys in a cleaner way focused on the algorithm rather than infrastructure details. Word count is shown implemented in the lower-level MapReduce API versus in Cascading Java code to demonstrate how Cascading minimizes boilerplate and exposes the right abstractions.
This document provides an overview of Gradle, including required knowledge, the Groovy language features it uses, how to define tasks and projects, adding dependencies, and using the Gradle wrapper. Gradle is a build automation tool that uses Groovy's Domain Specific Language to define scripts. It manages Java projects through conventions like source set directories and predefined tasks. Developers can customize builds with plugins and by defining new tasks in Groovy.
Новый InterSystems: open-source, митапы, хакатоныTimur Safin
Presentation for the 1st InterSystems Meetup in the Minsk:
- New and better InterSystems changes their practice.
- open-source repositories, meetups, and hackathon;
- CPM (package manager) as a good example of open-source project
Thrift and PasteScript are frameworks for building distributed applications and services. Thrift allows defining data types and interfaces using a simple definition language that can generate code in multiple languages. It uses a compact binary protocol for efficient RPC-style communication between clients and servers. PasteScript builds on WSGI and provides tools like paster for deploying and managing Python web applications, along with reloading and logging capabilities. It integrates with Thrift via server runners and application factories.
The document discusses dynamic C++ and the POCO library. It introduces the problem of accessing data in different formats and proposes POCO as a solution. POCO provides classes like RecordSet and Row that allow dynamically binding data and generating output in different formats like XML. It discusses the implementation details of how POCO achieves dynamic and type-safe behavior through templates and classes like Poco::Dynamic::Var.
Weaving Dataflows with Silk - ScalaMatsuri 2014, TokyoTaro L. Saito
Silk is a framework for building dataflows in Scala. In Silk users write data processing code with collection operators (e.g., map, filter, reduce, join, etc.). Silk uses Scala Macros to construct a DAG of dataflows, nodes of which are annotated with variable names in the program. By using these variable names as markers in the DAG, Silk can support interruption and resume of dataflows and querying the intermediate data. By separating dataflow descriptions from its computation, Silk enables us to switch executors, called weavers, for in-memory or cluster computing without modifying the code. In this talk, we will show how Silk helps you run data-processing pipelines as you write the code.
Pry is a powerful alternative to the standard IRB shell for Ruby. It features syntax highlighting, a flexible plugin architecture, runtime invocation and source and documentation browsing. Pry can be used in a Rails app by adding the pry and pry-byebug gems. Binding.pry allows stopping execution at specific points in code to inspect and modify values using Pry commands like ls, cd, and find-method. Pry provides many ways to introspect code like show-source and show-doc while allowing editing of methods and values on the fly.
The document introduces dynamic languages and provides examples comparing Java and Groovy implementations of a filtering task. It discusses the benefits of Groovy, including its Java-like syntax, dynamic typing, built-in support for lists/maps/arrays, closures, and additional libraries that simplify APIs. Groovy aims to integrate well with Java while adding meta-programming capabilities. The document provides examples of common uses of Groovy and its features.
This document provides an agenda and overview for a Spark workshop covering Spark basics and streaming. The agenda includes sections on Scala, Spark, Spark SQL, and Spark Streaming. It discusses Scala concepts like vals, vars, defs, classes, objects, and pattern matching. It also covers Spark RDDs, transformations, actions, sources, and the spark-shell. Finally, it briefly introduces Spark concepts like broadcast variables, accumulators, and spark-submit.
Javascript allows interactive content on web pages and control of the browser and document. It is an interpreted scripting language that is cross-platform but support varies. Javascript can provide interactive content, control document appearance and content, and interact with the user through event handlers.
Scalding: Twitter's Scala DSL for Hadoop/Cascadingjohnynek
Talk given at the 2012 Hadoop Summit in San Jose, CA.
Scalding is a Scala DSL for Cascading which brings natural functional programming to Hadoop. It is open-source, developed by Twitter and others.
Follow: twitter.com/scalding
github.com/twitter/scalding
This document provides an overview of Kotlin for backend development. It discusses Kotlin's advantages like Java interoperability and null safety. Coroutines are presented as an alternative to callback-based asynchronous programming. Examples are given of adopting Kotlin in different contexts like libraries, components and web applications. Strategies covered include preparing development tools and environments, evaluating current skills, and sharing experiences.
This document discusses Kotlin coroutines and how they can be used with the Spring Framework. It provides an overview of coroutines, explaining concepts like fibers, green threads, and suspendable computations. It also covers using coroutines with Spring features like the @Async annotation and asynchronous MVC return types. The document provides code examples of coroutines concepts like channels, jobs, and yielding in sequences.
In recent years we have seen explosion of languages which run on Java Virtual Machine. We also have seen existing languages getting their implementations being rewritten to JVM. With all of the above we have seen rapid development of tools like parsers, bytecode generators and such, even inside JVM we saw initiatives like Da Vinci Machine Project, which led to invoke dynamic in JDK 7 and recent development of Graal and Truffle projects.
Is it really hard to write new programming language running on JVM? Even if you are not going to write your own I think it is worth to understand how your favorite language runs undercover, how early decisions can impact language extensibility and performance, what JVM itself and JVM ecosystem has to offer to language implementors.
During the session I will try to get you familiar with options you have when choosing parsers and byte code manipulation libraries. which language implementation to consider, how to test and tune your "new baby". Will you be able after this session to develop new and shiny language, packed with killer features language? No. But for sure you will understand difference between lexers and parsers, how bytecode works, why invoke dynamic and Graal and Truffle are so important to the future of JVM platform. Will we have time to write simple, compiled language?
The document discusses optimizing Tcl bytecode. It provides an overview of Tcl's evaluation strategy using bytecode and discusses opportunities to improve bytecode compilation coverage, generation, and optimization. The author outlines work done to compile more commands to bytecode, improve bytecode for operations like list concatenation, and add an initial bytecode optimizer. Benchmark results show performance improvements from these changes ranging from 10-40% depending on the operation. Future work is needed to fully optimize control flow, eliminate dead code, and close the gap between the assembler and optimizer.
This module explains several additional important concepts. These include properties of QObjects, data types, QString and various list types.
Special classes in Qt provide even more convenient APIs if you want to save settings in the right way for the target platform.
At the end, a guide walks you through what you need to know about embedding files and resources into your application.
This document summarizes Martin Odersky's opening address at Scala eXchange in 2011 about the past, present and future of Scala. It discusses Scala's trajectory over the past 10 years from its initial development to widespread industrial adoption. It identifies concurrency and parallelism as a key concern going forward and outlines Scala's tools for both implicit and explicit parallel programming.
The document provides a list of 57 annoying yet fun things to do in an elevator and 29 annoying ways to order a pizza to annoy the person taking the order. It also lists 18 fun things to do during a final exam that does not matter, 9 fun things to do during a boring lecture, and 5 ways to confuse or scare people in a computer lab. Finally, it provides 20 ways to annoy the person in the neighboring stall in a public bathroom. The behaviors range from making strange noises and comments to playing pranks on neighbors in the stalls. The purpose seems to be providing amusing yet annoying things to do in common situations.
Dean Wampler presents on using Scalding, which leverages Cascading, to write MapReduce jobs in a more productive way. Cascading provides higher-level abstractions for building data pipelines and hides much of the boilerplate of the Hadoop MapReduce framework. It allows expressing jobs using concepts like joins and group-bys in a cleaner way focused on the algorithm rather than infrastructure details. Word count is shown implemented in the lower-level MapReduce API versus in Cascading Java code to demonstrate how Cascading minimizes boilerplate and exposes the right abstractions.
This document provides an overview of Gradle, including required knowledge, the Groovy language features it uses, how to define tasks and projects, adding dependencies, and using the Gradle wrapper. Gradle is a build automation tool that uses Groovy's Domain Specific Language to define scripts. It manages Java projects through conventions like source set directories and predefined tasks. Developers can customize builds with plugins and by defining new tasks in Groovy.
Новый InterSystems: open-source, митапы, хакатоныTimur Safin
Presentation for the 1st InterSystems Meetup in the Minsk:
- New and better InterSystems changes their practice.
- open-source repositories, meetups, and hackathon;
- CPM (package manager) as a good example of open-source project
Thrift and PasteScript are frameworks for building distributed applications and services. Thrift allows defining data types and interfaces using a simple definition language that can generate code in multiple languages. It uses a compact binary protocol for efficient RPC-style communication between clients and servers. PasteScript builds on WSGI and provides tools like paster for deploying and managing Python web applications, along with reloading and logging capabilities. It integrates with Thrift via server runners and application factories.
The document discusses dynamic C++ and the POCO library. It introduces the problem of accessing data in different formats and proposes POCO as a solution. POCO provides classes like RecordSet and Row that allow dynamically binding data and generating output in different formats like XML. It discusses the implementation details of how POCO achieves dynamic and type-safe behavior through templates and classes like Poco::Dynamic::Var.
Weaving Dataflows with Silk - ScalaMatsuri 2014, TokyoTaro L. Saito
Silk is a framework for building dataflows in Scala. In Silk users write data processing code with collection operators (e.g., map, filter, reduce, join, etc.). Silk uses Scala Macros to construct a DAG of dataflows, nodes of which are annotated with variable names in the program. By using these variable names as markers in the DAG, Silk can support interruption and resume of dataflows and querying the intermediate data. By separating dataflow descriptions from its computation, Silk enables us to switch executors, called weavers, for in-memory or cluster computing without modifying the code. In this talk, we will show how Silk helps you run data-processing pipelines as you write the code.
Pry is a powerful alternative to the standard IRB shell for Ruby. It features syntax highlighting, a flexible plugin architecture, runtime invocation and source and documentation browsing. Pry can be used in a Rails app by adding the pry and pry-byebug gems. Binding.pry allows stopping execution at specific points in code to inspect and modify values using Pry commands like ls, cd, and find-method. Pry provides many ways to introspect code like show-source and show-doc while allowing editing of methods and values on the fly.
The document introduces dynamic languages and provides examples comparing Java and Groovy implementations of a filtering task. It discusses the benefits of Groovy, including its Java-like syntax, dynamic typing, built-in support for lists/maps/arrays, closures, and additional libraries that simplify APIs. Groovy aims to integrate well with Java while adding meta-programming capabilities. The document provides examples of common uses of Groovy and its features.
This document provides an agenda and overview for a Spark workshop covering Spark basics and streaming. The agenda includes sections on Scala, Spark, Spark SQL, and Spark Streaming. It discusses Scala concepts like vals, vars, defs, classes, objects, and pattern matching. It also covers Spark RDDs, transformations, actions, sources, and the spark-shell. Finally, it briefly introduces Spark concepts like broadcast variables, accumulators, and spark-submit.
Javascript allows interactive content on web pages and control of the browser and document. It is an interpreted scripting language that is cross-platform but support varies. Javascript can provide interactive content, control document appearance and content, and interact with the user through event handlers.
Scalding: Twitter's Scala DSL for Hadoop/Cascadingjohnynek
Talk given at the 2012 Hadoop Summit in San Jose, CA.
Scalding is a Scala DSL for Cascading which brings natural functional programming to Hadoop. It is open-source, developed by Twitter and others.
Follow: twitter.com/scalding
github.com/twitter/scalding
This document provides an overview of Kotlin for backend development. It discusses Kotlin's advantages like Java interoperability and null safety. Coroutines are presented as an alternative to callback-based asynchronous programming. Examples are given of adopting Kotlin in different contexts like libraries, components and web applications. Strategies covered include preparing development tools and environments, evaluating current skills, and sharing experiences.
This document discusses Kotlin coroutines and how they can be used with the Spring Framework. It provides an overview of coroutines, explaining concepts like fibers, green threads, and suspendable computations. It also covers using coroutines with Spring features like the @Async annotation and asynchronous MVC return types. The document provides code examples of coroutines concepts like channels, jobs, and yielding in sequences.
In recent years we have seen explosion of languages which run on Java Virtual Machine. We also have seen existing languages getting their implementations being rewritten to JVM. With all of the above we have seen rapid development of tools like parsers, bytecode generators and such, even inside JVM we saw initiatives like Da Vinci Machine Project, which led to invoke dynamic in JDK 7 and recent development of Graal and Truffle projects.
Is it really hard to write new programming language running on JVM? Even if you are not going to write your own I think it is worth to understand how your favorite language runs undercover, how early decisions can impact language extensibility and performance, what JVM itself and JVM ecosystem has to offer to language implementors.
During the session I will try to get you familiar with options you have when choosing parsers and byte code manipulation libraries. which language implementation to consider, how to test and tune your "new baby". Will you be able after this session to develop new and shiny language, packed with killer features language? No. But for sure you will understand difference between lexers and parsers, how bytecode works, why invoke dynamic and Graal and Truffle are so important to the future of JVM platform. Will we have time to write simple, compiled language?
The document discusses optimizing Tcl bytecode. It provides an overview of Tcl's evaluation strategy using bytecode and discusses opportunities to improve bytecode compilation coverage, generation, and optimization. The author outlines work done to compile more commands to bytecode, improve bytecode for operations like list concatenation, and add an initial bytecode optimizer. Benchmark results show performance improvements from these changes ranging from 10-40% depending on the operation. Future work is needed to fully optimize control flow, eliminate dead code, and close the gap between the assembler and optimizer.
This module explains several additional important concepts. These include properties of QObjects, data types, QString and various list types.
Special classes in Qt provide even more convenient APIs if you want to save settings in the right way for the target platform.
At the end, a guide walks you through what you need to know about embedding files and resources into your application.
This document summarizes Martin Odersky's opening address at Scala eXchange in 2011 about the past, present and future of Scala. It discusses Scala's trajectory over the past 10 years from its initial development to widespread industrial adoption. It identifies concurrency and parallelism as a key concern going forward and outlines Scala's tools for both implicit and explicit parallel programming.
The document provides a list of 57 annoying yet fun things to do in an elevator and 29 annoying ways to order a pizza to annoy the person taking the order. It also lists 18 fun things to do during a final exam that does not matter, 9 fun things to do during a boring lecture, and 5 ways to confuse or scare people in a computer lab. Finally, it provides 20 ways to annoy the person in the neighboring stall in a public bathroom. The behaviors range from making strange noises and comments to playing pranks on neighbors in the stalls. The purpose seems to be providing amusing yet annoying things to do in common situations.
6 Most Annoying Things People Do On FacebookSimplify360
The document discusses six types of annoying social media behaviors, including receiving random pokes or friend requests from strangers, getting tagged in irrelevant photos, seeing constant pointless status updates, and excessive game and promotional requests. It notes how these behaviors such as random tags, challenges to change one's status, and requests to like unrelated content can annoy social media users. The document is written by a social media analyst and contains images to illustrate each annoying behavior.
There are many small annoyances that can ruin an otherwise good day. From minor inconveniences like slow internet or traffic jams to more bothersome issues like rude customers or long lines, it is easy to become irritated by life's little frustrations. Learning to let small problems roll off your back can help you maintain a more positive outlook even when faced with life's inevitable annoyances.
This document discusses issues related to growing up, including snatching, street crimes, and cyber crimes. It aims to understand the problem statement, research questions, types of crimes occurring in Karachi including those committed by mafias, and the effect of the economy on cyber crimes in Pakistan. The document examines reasons for cyber crimes and their impact.
Ada Lovelace was born in 1815 to Lord Byron and Anne Isabella Milbanke. She was interested in math and science from a young age and studied under private tutors. At 17, she met Charles Babbage and assisted him with his analytical engine, publishing the first algorithm for computation with the device, making her the first computer programmer. She had two children with her husband William King-Noel, 1st Earl of Lovelace, and although her work was not recognized until the 1950s, she left an important legacy as the first computer programmer.
Clocks have evolved significantly over time. Early mechanical clocks kept time using intricate systems of gears and pendulums. Modern electronic clocks now keep time using tiny integrated circuits and quartz crystals that vibrate at a precise frequency, allowing for much greater accuracy than early mechanical timepieces.
The document discusses various tools that are part of the GNU toolchain used for embedded software development. It provides descriptions of common tools used with the GNU Compiler Collection (GCC) such as ar, autoconf, as, gdb, ld, libtool, make, nm, objcopy, objdump, ranlib, readelf, size, strings and strip. It also covers topics like the preprocessor, compiler options, anonymous unions, arrays of zero length, and using attributes with GCC.
Pentesting iOS Apps - Runtime Analysis and ManipulationAndreas Kurtz
Apple iOS Apps are primarily developed in Objective-C, an object-oriented extension and strict superset of the C programming language. Objective-C supports the concepts of reflection, also known as introspection. This describes the ability to examine and modify the structure and behavior (specifically the values, meta-data, properties and functions) of an object at runtime.
This talk discusses the background, techniques, problems and solutions to Objective-C runtime analysis and manipulation. It will be discussed how running applications can be extended with additional debugging and runtime tracing capabilities, and how this can be used to modify instance variables and to execute or replace arbitrary object methods of an App.
Moreover, a new framework to assist dynamic analysis and security assessments of iOS Apps will be introduced and demonstrated.
The document provides an introduction to compilers. It discusses that compilers are language translators that take source code as input and convert it to another language as output. The compilation process involves multiple phases including lexical analysis, syntax analysis, semantic analysis, code generation, and code optimization. It describes the different phases of compilation in detail and explains concepts like intermediate code representation, symbol tables, and grammars.
This document compares interpreters and compilers. Both interpreters and compilers convert high-level programming code into machine-readable code, but they differ in how they accomplish this. Interpreters convert and execute code line-by-line, making debugging easier but programs slower. Compilers analyze the entire program at once before executing it, making programs faster but debugging more difficult. Examples of interpreters include JavaScript and BASIC, while C, C++, and Java are typically compiled languages.
Perfect phrases for customer service angry customersmindylcarter
This document provides guidance on customer service techniques for handling complaints and difficult customers. Some key points:
1) It's important to listen to customers' complaints without being defensive and understand their perspective. Phrases like "that's interesting..." can encourage customers to explain further without accusation.
2) Apologize for any problems or inconvenience, assure customers you want to resolve the issue, and thank them for bringing it to your attention.
3) Remain calm and sympathetic; get the full details of the problem without blaming others; offer solutions and end on a positive note thanking them. Treating customers with respect and focusing on solutions is key to resolving complaints.
The use of the code analysis library OpenC++: modifications, improvements, er...PVS-Studio
The document discusses modifications and improvements made to the OpenC++ code analysis library. It describes 15 modifications to the library related to error corrections or adding new functionality. The modifications include adding support for new keywords, skipping compiler-specific keywords, getting values of numerical literals, and fixing file paths. The purpose is to help developers use and improve OpenC++, while also demonstrating how to modify the library code.
This document provides an introduction to C++ programming using Code::Blocks. It discusses getting started with Code::Blocks on terminals or one's own laptop. The tutorial outline includes a brief history of C++, an introduction to object-oriented programming, when C++ is a good choice, and creating a first "Hello, World" program in Code::Blocks. The document provides an overview of compiling and running a C++ program in Code::Blocks.
Whats New in Visual Studio 2012 for C++ DevelopersRainer Stropek
For a Microsoft event we have been hired to do a full-day workshop about news in Visual Studio 2012 for C++ developers. My colleague Philipp Aumayr conducted the workshop. Here are the slides for his talk. More details including sample code can be found in our developer blog at http://www.software-architects.com
The document discusses several software development best practices including source control, coding standards, design patterns, documentation, testing, and deployment. It provides examples and explanations of common design patterns like factory, registry, adapter, decorator, and observer. Resources for further information on topics like Subversion, Git, coding standards, and design patterns are also referenced.
Large-scale C++ development is tough business, and so is grokking and improving OOo's approximately 6 million lines of code. The author will share the accumulated knowledge of Sun's OOo development team, touching areas such as:
* dependency management: how to architect for encapsulation
* tools for working on the code: IDE/editor review, (semi)-automatic code transformations and refactorings, debuggers
* patterns: the most frequent design patterns and their incarnations
* helpers: the what and the where of helper functionality
* recommended readings: literature, links to OOo resources (API documentation, coding guidelines), mailing lists and news groups
This session should be suitable for all levels of C++ programmers, that want to become familiar with OOo's way of doing things in C++.
Advanced Rational Robot A Tribute (http://www.geektester.blogspot.com)raj.kamal13
This document provides information about Rational Robot testing software including:
1. An advanced course is designed to teach complex automated testing techniques using Rational Robot such as building effective test scripts through best practices.
2. Rational Robot can be used to record, playback, and view logs of test scripts. It also supports different types of header and library files to share code between scripts.
3. Various recording modes, verification points, and clipboard commands are described that allow Rational Robot to test different types of applications in flexible ways.
This document provides instructions for setting up an EJB 3 project that integrates with the Struts framework. It explains how to create EJB and web projects using MyEclipse. It also describes adding required libraries, creating entity beans for Book and Customer objects, and adding JPA annotations to define primary keys and entity mappings.
This document provides instructions for setting up an EJB 3 project that integrates with the Struts web framework. It describes creating entity beans for Book and Customer objects and defining the relationship between them. It also covers implementing a stateless session bean with local and remote interfaces to perform basic CRUD operations using the entity manager. The tutorial uses PostgreSQL as the database and provides code samples for the entity beans, session bean, and persistence configuration file.
The Hitchhiker's Guide to Faster Builds. Viktor Kirilov. CoreHard Spring 2019corehard_by
C++ is known for things such as performance, expressiveness, the lack of a standard build system and package management, complexity and long compile times. The inability to iterate quickly is one of the biggest killers of productivity. This talk is aimed at anyone interested in improving the last of these points - it will provide insights into why compilation (and linking) take so long for C++ and will then provide an exhaustive list of techniques and tools to mitigate the problem, such as: - tooling and infrastructure - hardware, build systems, caching, distributed builds, diagnostics of bottlenecks, code hygiene - techniques - unity builds, precompiled headers, linking (static vs shared libraries) - source code modification - the PIMPL idiom, better template use, annotations - modules - what they are, when they are coming to C++ and what becomes obsolete because of them
Don't be fooled by the thumbnail - the first couple of slides are a silly joke I forgot to remove before uploading.
Presentation derived from the "What's new in Python 2.4" document on http://www.python.org/ including much reformatting for presenting and presenter notes.
Please download the Keynote original - that way the presentation notes aren't burned into the slides.
The document discusses the different states that a package's contents can be stored in, including as a source, bundle, binary, or installed in an R library or online repository. It also lists several functions that can be used to move a package between these states, such as install.packages(), devtools::install(), and library(). The bottom portion provides a cheat sheet on common parts of an R package like the DESCRIPTION file, namespaces, documentation, data, testing, and more.
The document discusses the different states that a package's contents can be stored in, including as a source, bundle, binary, or installed in an R library or online repository. It also lists several functions that can be used to move a package between these states, such as install.packages(), devtools::install(), and library(). The bottom portion provides a cheat sheet on common parts of an R package like the DESCRIPTION file, namespaces, documentation, data, testing, and more.
The document discusses various techniques for implementing reflection in object-oriented programming languages like Smalltalk. It describes approaches for controlling message passing through minimal objects, anonymous classes, and method substitution. Minimal objects intercept messages using doesNotUnderstand:, while anonymous classes are inserted between instances and their classes to control lookup. Method substitution directly replaces methods to add control. The document analyzes the tradeoffs of different reflective approaches.
This document provides an overview of Lex, a lexical analyzer generator tool. It discusses installing and running Lex on Windows and Linux systems, and provides an example Decaf programming language lexical analyzer code. The code is run on sample input to generate a tokenized output file. The document contains sections on what Lex is, the structure of Lex programs, predefined Lex variables and library routines, setting up and running Lex on different platforms, and an example Decaf program with its output.
The document provides definitions for various computer science and programming terms related to C++ including data types, operators, statements, functions, classes, inheritance, and more. It defines terms such as #include, abstract class, aggregate, alias, allocation, argument, array, assignment, base class, bit, bool, break, byte, call by reference, call by value, case, char, cin, class, class layout, class member, class template, comments, compiler, const, constructor, continue, copy constructor, cout, data structure, debugger, declaration, default argument, definition, delete operator, derived class, destructor, do, double, dynamic memory allocation, else, endl, explicit, expression, expression statement
The document describes a presentation about data processing with CDK (Cloud Development Kit). It includes an agenda that covers CDK and Projen, serverless ETL with Glue, Databrew with continuous integration/continuous delivery (CICD), and using Amazon Comprehend with S3 object lambdas. Constructs are demonstrated for building architectures with CDK across multiple programming languages. Examples are provided of using CDK to implement Glue workflows, Databrew CICD pipelines, and combining Comprehend with S3 object lambdas for PII detection and redaction.
The document provides an overview of the C++ programming language. It discusses that C++ was created by Bjarne Stroustrup to provide Simula's facilities for program organization together with C's efficiency and flexibility for systems programming. The document outlines key C++ features like classes, templates, operator overloading, and exceptions. It also covers topics like class definitions, constructors, destructors, streams, and compiling/linking C++ programs.
The document outlines a lecture plan for object oriented programming. It covers topics like structures and classes, function overloading, constructors and destructors, operator overloading, inheritance, polymorphism, and file streams. It provides examples to explain concepts like structures, classes, access specifiers, friend functions, and operator overloading. The document also includes questions for students to practice these concepts.
This document provides summaries of 3 cheat sheets for Java developers:
1. The Java 8 Streams cheat sheet defines streams, terminal and intermediate operations, parallel streams, and common pitfalls. It includes examples of using streams to filter, map, and collect data.
2. The Java Collections cheat sheet compares the performance of common collection classes and lists thread-safe alternatives. It also introduces notable Java collections libraries.
3. The Git cheat sheet outlines commands for creating and working with repositories, branches, tags and commits. It provides shortcuts for fetching updates, pushing changes, and viewing history and diffs.
1. CSE 380 C++ Boot Camp
Part 2/2
You
You
C++
C++
Subtle and
Subtle and
annoying things
annoying things
2. Now what?
●
Last week: The language
●
This week: The tools
●
Compiling and linking code
●
Box2D, specifically
●
You will be using it for your course project
●
Splitting classes into headers and source files
●
What that means and why you must do it
●
Overview of popular C++ libraries and tools
●
Tips about the course
3. Static vs. Dynamic Libraries
.a or .lib extension
(varies by compiler)
Resolved at link-time and
included in the binary
Must recompile to update
the library
Unused or duplicated
library code can be
removed
.dylib, .dll, or .so
extension (varies by OS)
Resolved at run-time and
included in program
directory or system folders
Can swap out different
versions at will
Only loaded to RAM once
if multiple programs use
the same dynamic library
at the same time
5. Symbol Tables
moe.obj
moe.obj
Have: stooges::slap
Have: std::vector<float>
Seeking: stooges::poke
Seeking: std::sin
Multiple gaps seeking one symbol: Perfectly normal
Multiple tabs declaring one symbol: multiple definition of
symbol symbol_name
Gap without a tab filling it: unresolved external symbol
symbol_name
Tab not assigned to a gap: Unused symbol (can be stripped)
7. Installing Box2D
I assume you've downloaded Visual Studio already
Download Box2D now
– And 7-Zip to open the archive
Extract the Box2D_v2.3.0/Box2D folder to wherever you want to keep
your libraries
I use C:/Users/<name>/Libraries
All of your libraries should go
here (with a folder for each)
Does this
contain these?
8. Compiling Box2D
Projects contain related code
Solutions contain related projects
Open Build/vs2012/Box2D.sln
#include that
in your game
For testing
and demos
Right-click Box2D → Build
You just built a static library!
9. Compiling Box2D
Do the same with Testbed
Note that its dependencies are compiled
See Solution 'Box2D' → Properties → Project Dependencies
Testbed → Debug → Start New Instance
Play around with this over the weekend
10. What did you just build?
Box2D → Properties
The most
important
stuff
Change options depending on build type and platform
Macros have different values
depending on config or build
environment
11. Release Builds
Run the Testbed, go to Tiles demo, tick the Profile box
Look at step [ave] (max); note these numbers
previous [average] (longest time) for one physics step in milliseconds
Do it again in Release mode
WOW!
Debug build Release build
12. Creating a Solution
Your solution will have multiple projects
Your game + any supporting libraries
File → New → New Project
Create a new solution
13. Let's Compile Something
Source Files → Add New Item → C++ File
#include <iostream>
#include <cstdlib>
using std::cout;
using std::endl;
using std::system;
int main() {
cout << "Hello world!" << endl;
system("PAUSE");
}
14. Headers and Classes
Declare classes, global functions, etc. in header files
(.hpp extension)
Define them in a corresponding source file (.cpp
extension)
Exception: templated classes, functions, or methods
must be defined in headers
15. Headers and Classes
Reduces the number of files to build
Header changes? All .cpp files that use it
must be recompiled
Source changes? Only that file must be
recompiled
Prevent linker errors, too
16. You Should See These
// Vector2.hpp
#pragma once
class Vector2
{
public:
Vector2();
~Vector2();
};
// Vector2.cpp
#include "Vector2.hpp"
Vector2::Vector2()
{
}
Vector2::~Vector2()
{
}
Provides symbols Provides code
17. More (.hpp)
// Vector2.hpp
#pragma once
namespace cse380 {
class Vector2
{
public:
Vector2();
Vector2(const float, const float);
// Can omit names in declaration
float x, y;
Vector2& operator+=(const Vector2&);
Vector2& operator*=(const float);
};
Vector2 operator+(const Vector2&, const Vector2&);
Vector2 operator*(const Vector2&, const float);
}
21. Now Add a Conversion Operator
// Vector2.hpp
#pragma once
#include
#include "Vector3.hpp"
"Vector3.hpp"
namespace cse380 {
class Vector2
{
public:
// Omitted for brevity
explicit
explicit operator
operator Vector3
Vector3()
() const
const;
;
};
// Omitted for brevity
}
// Vector2.cpp
#include "Vector2.hpp"
namespace cse380 {
// Omitted for brevity
Vector2
Vector2::
::operator
operator cse380::
cse380::Vector3
Vector3()
() const
const {
{
return
return Vector3
Vector3(
(this
this->x,
->x, this
this->y, 0);
->y, 0);
}
}
// Omitted for brevity
}
You just tried a circular #include!
Won't compile; incomplete type
22. What to Do
// Vector2.hpp
#pragma once
#include "Vector3.hpp"
namespace cse380 {
class
class Vector3
Vector3;
;
// Omitted for brevity
}
// Vector3.hpp
#pragma once
#include "Vector2.hpp"
namespace cse380 {
class
class Vector2
Vector2;
;
// Omitted for brevity
}
// Vector3.cpp
#include "Vector3.hpp"
#include
#include "Vector2.hpp"
"Vector2.hpp"
namespace cse380 {
// Omitted for brevity
}
// Vector2.cpp
#include "Vector2.hpp"
#include
#include "Vector3.hpp"
"Vector3.hpp"
namespace cse380 {
// Omitted for brevity
}
Forward-declare a class when you only need its name
This is why we split classes into .hpp/.cpp
#include its header when you need anything else (including sizeof)
i.e. in dependent .cpp files or templates in headers
Two classes can't be members of each other
Raw pointers (not smart pointers) to each other okay
24. #pragma once
Include at the top of each .hpp
Otherwise the same class is effectively
defined multiple times
#include "Vector2.hpp"
#pragma once
// Contents of Vector2.hpp
<nothing>
First time this file
was #included?
Yes
No
25. With
#pragma once
Without
#pragma once
#pragma once
// France.hpp
// Spain.hpp
#include "France.hpp"
// Before
#include "France.hpp"
#include "Spain.hpp"
int main() {
// Etc.
}
// France.hpp
#pragma once
// Spain.hpp
#pragma once
#include "France.hpp"
// Hooray!
// France.hpp
// Spain.hpp
int main() {
// It works!
}
// Uh-oh
// France.hpp
// Spain.hpp
// France.hpp
int main() {
// Multiple
// definition error
}
26. Library/Include Install
Conventions
Linux
●
/usr/include and /usr/lib for
package managers
●
/usr/local/include and
/usr/local/lib for everything
else
Mac
●
/Library/Frameworks
Project-Specific
●
Enforce a location
●
“Use your home folder”
●
Include in your source tree
●
Recommended for this course
●
Submodules
Windows
●
None
●
God help you
28. Importing Box2D
●
Still gotta add the include/library paths
●
Project → VC++ Directories
●
If you and your team aren't consistent, you
will lose lots of sleep
The important stuff
29. Importing Box2D
●
Add <RootBox2DDir>Box2D
to includes
●
Change your main to this:
Expands to these
Nice and easy
Filter by macro name
#include <iostream>
#include <cstdlib>
#include
#include "Vector2.hpp"
"Vector2.hpp"
#include
#include "Vector3.hpp"
"Vector3.hpp"
#include
#include <Box2DBox2D.h>
<Box2DBox2D.h>
using std::cout;
using std::endl;
using std::system;
using
using namespace
namespace cse380;
cse380;
int main() {
b2World
b2World world(b2Vec2_zero);
world(b2Vec2_zero);
Vector2
Vector2 a(2, 3);
a(2, 3);
Vector3
Vector3 b;
b;
cout << "Hello world!" << endl;
system("PAUSE");
}
// Not done yet; you'll get a linker error!
40. UPX
Compress executables and
libraries
Output automatically
decompresses when run
Output may trigger virus
scanners
– They hate self-modifying code
Compressed DLLs cannot
be shared between
programs
41. Visual Studio Tips
Don't be afraid to customize it
Most of today's lessons are not specific to it
You can define tasks to run upon a
successful build (e.g. zipping up the
game/assets, copying over any DLLs, etc.)
42. Box2D Tips
Box2D has a lot of classes; most of these are only used
internally
I'll make a list of classes to care about later
There is an abstract b2Draw class you can extend for
drawing bodies, joints, etc.
USE IT USE IT USE IT USE IT USE IT
Don't use pixels as world units; pick a size (e.g. 64px = 1
meter) and use that
Otherwise it's hard to reason about world design