The document discusses debugging effectively. It begins with an overview of the importance of debugging and the debugging process. It then covers specific debugging tools and techniques, including using an integrated development environment (IDE) and interactive debugger. It outlines a systematic debugging approach and provides tips for junior developers. Specific techniques like tracing code backwards and forwards are presented. The importance of gathering information, replicating issues, and ruling out assumptions is emphasized.
This document summarizes key concepts of Git including snapshots, histories as sequences of snapshots, parallel universes/histories, and basic Git commands like init, add, commit, branch, checkout, merge, rebase, remote repositories, and free hosting services. The document uses diagrams and examples to explain how Git conceptually implements versions as snapshots and allows managing parallel software histories through branches.
Short introduction about vcs & git usage.
Aimed to introduce concept of version control system and git to people who didn't used git or vcs yet. Doesn't introduce deep part of git or operating policy for git. Just focus on simple introduction about main functionality and abstracted internal design.
Describe how to contribute to open source projects.
Provide example process using two hot open source project, linux and AOSP(Android Open Source Project)
The document discusses a tool called Versions that checks for new releases of projects. It started as a hardcoded script but was refactored to use a YAML configuration file to make it more flexible and maintainable. The tool supports checking versions from many sites by parsing release notes with regex. While versioning schemes vary, the tool handles irregularities through configuration. Feedback from users helped improve the tool's capabilities and identify bugs.
Effective Git - EclipseCon 2011 tutorial
Tutorial slides, the corresponding tutorial exercises are published here https://docs.google.com/leaf?id=0B4F_gjXVrHZVMzE5MWNmNjktMDcxMS00NDM3LWI4NDQtYmE1YzZkM2RkY2Rl&hl=en
Is Docker really the security risk that is generally raged about? Or, is this more about understanding where and when a business should consider adoption new and revolutionary infrastructure?
Feedback en continu grâce au TDD et au AsCodeHaja R
The document discusses the concepts of test-driven development (TDD), continuous integration, infrastructure as code, and documentation as code. It provides examples of writing specifications, documentation, build pipelines, and infrastructure using code and formats like Markdown, YAML, Puppet, Ansible, Dockerfiles, and Docker Compose files. Emphasizing that treating all aspects of software development as code enables continuous feedback, communication, and versioning.
The document discusses the basics of Git version control system. It begins with an overview of key Git concepts like snapshots of the project files rather than file differences. It then demonstrates Git functionality through a simple example of adding, modifying and renaming files in a sample project. The example shows how Git records the changes through commits and is able to reconstruct previous versions of the files from snapshots. It also touches on concepts like branches and merges.
This document is a presentation on Git and GitHub given by Olmo Maldonado. It introduces version control and why it is useful, especially for collaboration. It describes what Git and GitHub are and how they work together. The presentation walks through finding and following projects and users on GitHub. It also covers basic Git commands like cloning a repository, making changes, adding/committing, pushing changes to a remote repository, and creating/merging branches. It emphasizes using GitHub and pull requests for collaboration on projects.
The document discusses Dockerized system testing using Arquillian Cube. It provides an overview of Arquillian Cube, which allows testing applications running in Docker containers or container-less environments. It demonstrates configuring Arquillian XML to specify Docker containers and properties, as well as writing tests that target applications deployed to Docker containers using Arquillian resources.
2011 Learning Age – SCORM for Games and Simulations – Mike RusticiRustici Software
This document discusses how SCORM (Sharable Content Object Reference Model) can be used for games and simulations. It provides examples of how SCORM data can be captured for different learning activities like completing courses, teaching courses, attending events, participating in simulations, and more. It also outlines some limitations of the current SCORM standard and introduces new specifications like Tin Can and ADL Flex that aim to address these limitations and expand what can be tracked for learning activities.
Tim Martin presented on Project Tin Can at the ASTD TechKnowledge 2012 conference. Project Tin Can is a new specification that aims to track learning activities across different systems and devices. It allows for on the fly entity creation, device transitions, and decoupled data models to address limitations of previous specifications like SCORM. However, fully realizing its potential will require addressing challenges like out of browser experiences, offline access, security, and alternate device formats.
The document discusses tools and processes for building and maintaining large websites and web applications. It covers topics like source control, bug tracking, continuous integration, testing, release management, monitoring, and automation. The overall message is that tools can help manage complexity when developing, deploying, and maintaining software, and automation of common tasks is important for large projects.
This document contains notes from a presentation on refactoring code. It includes links to resources on refactoring katas, test-driven development, and notation for commits. The presentation discusses writing tests, lifting conditionals during refactoring, splitting code into classes, adding new functionality, and resources for learning more about refactoring and advanced testing techniques.
Software bugs are inevitable; some are especially difficult to track down, causing you to waste countless hours before throwing your hands up in defeat. It doesn't have to be this way! The mental fatigue and wasted time can be avoided by using strategies like identifying the most-appropriate tool, taking a logical & objective approach, challenging assumptions, listening to variables, isolating the code path, and reinforcing code with automated tests. Attendees will learn how to combine these techniques with the right mindset and attitude in order to debug their code quickly and effectively.
Debugging Effectively - Frederick Web Tech 9/6/16Colin O'Dell
Software bugs are inevitable; some are especially difficult to track down, causing you to waste countless hours before throwing your hands up in defeat. It doesn't have to be this way! The mental fatigue and wasted time can be avoided by using strategies like identifying the most-appropriate tool, taking a logical & objective approach, challenging assumptions, listening to variables, isolating the code path, and reinforcing code with automated tests. Attendees will learn how to combine these techniques with the right mindset and attitude in order to debug their code quickly and effectively.
The Seven Wastes of Software DevelopmentMatt Stine
This document summarizes Matt Stine's presentation on the seven wastes of software development based on lean manufacturing principles. The seven wastes are: partially done work, extra processes, extra features, handoffs, delays, task switching, and defects. Stine provides examples of each waste and solutions to eliminate them, such as limiting work in progress, continuous integration, avoiding handoffs, minimizing task switching, and early defect detection. The goal is to reduce non-value adding activities and continuously improve productivity and quality.
Let the contribution begin (EST futures)SeongJae Park
The document discusses contributing to open source software as a newcomer. It recommends getting the source code, making small, targeted changes like fixing coding style issues, and submitting patches for review. The Linux kernel is presented as a popular project to start contributing to. Topic branches in version control are introduced as a way to develop changes separately before submitting them for merging.
Chaos Engineering on Microservices - 윤석찬, AWS 테크에반젤리스트 Channy Yun
This document contains information about chaos engineering and experimenting with latency injection between microservices. It discusses distributing traffic between production, control, and experimental versions of a service called Service A. 98% of traffic would go to the production version, 1% to the control version, and 1% to the experimental version where latency is injected between Service A and downstream services using an injector. This allows experimenting with how systems react to different latency conditions to test resilience and identify problems.
This document summarizes a presentation about managing Docker images with Concourse. It discusses building Docker images from a Dockerfile, triggering image builds when the Dockerfile or dependencies change. It also covers storing and pushing images, and using a Concourse pipeline to check for new images and code commits, rebuild images, tag images and the code repository with the new version.
Making the Web Fireproof: A Building Code for WebsitesDylan Wilbanks
The moment we start creating a website, we’re setting ourselves up for failure later. Bad code creates middle of the night fire drills. Lack of thinking about accessibility gets our employer sued. Not thinking ahead on mobile generates rework. We accept this as the normal course of business – but is there any way we could prevent (or lower) this cost? Is there anything we can learn from the building codes that dictate how our built environment is constructed?
We will talk about the lessons of building codes and what we can do today to build more robust web applications and sites, including:
- The need for design patterns in websites
- The need for patterns in user stories so that we build websites consistently
- Baking accessibility into websites comes from putting accessibility into user stories
- Planning a web application is different from planning a building, but it does share similar aspects of work
- The better we can becoming at creating best practices (building codes) the better we will get at building sites, and the closer we will come to Berners-Lee’s “one web for all” dream
Presented at MinneWebCon 2015.
This document provides an overview of continuous integration (CI) and Jenkins 2. It introduces the speaker and their experience with Hudson and Jenkins. It discusses CI practices like maintaining a single source repository and automating builds. It also covers related practices like continuous delivery and the Jenkins pipeline plugin. The document contains screenshots and diagrams to illustrate CI and Jenkins concepts and configuration options.
Virtual machines and volunteer computing platforms like BOINC allow researchers to utilize idle computing resources from home PCs. Projects like LHC@Home and Test4Theory have harnessed thousands of PCs through BOINC, generating CPU years worth of computing. While running actual LHC experiments is challenging due to code porting and library issues, Test4Theory demonstrates BOINC's ability to run physics simulations. It has engaged over 4,500 users who have generated over 230 billion simulation events. BOINC supports virtualization which provides custom execution environments and security while enabling multi-core processing and development on a single platform. Community feedback is also important for improving volunteer computing projects.
- Concourse is a CI/CD tool that uses pipelines defined in YAML to automate workflows. It runs builds inside containers for isolation.
- It has three main concepts: resources that define inputs/outputs, tasks that define individual build steps, and jobs that define the actions in the pipeline.
- Concourse uses a pluggable resource model so many types of resources can be used as inputs or outputs like Git, Docker images, S3, etc. It can also integrate custom resource types.
- Tasks always behave the same way if inputs are the same. Jobs determine the order of tasks and resources in the pipeline.
- Concourse is installed either locally with Vagrant or on a cluster with Bosh
This document discusses agile planning and requirements gathering. It begins with an overview of iterative development processes and user stories. Users then engage in activities to write and revise their own user stories for a sample system. Principles of user stories are explained, such as being minimalist and backed by acceptance tests. Methods for gathering, estimating, and prioritizing user stories are then covered, including planning poker. The goal is for engineers to provide honest estimates that customers can trust and refine over time at a sustainable pace.
신뢰성 높은 클라우드 기반 서비스 운영을 위한 Chaos Engineering in Action (윤석찬, AWS 테크에반젤리스트) :: ...Amazon Web Services Korea
This document discusses concepts related to chaos engineering including:
1. Many large tech companies like Amazon, Netflix, and Google practice chaos engineering to test system resiliency through failure injection and destruction testing.
2. Netflix developed open source tools like Chaos Monkey and Simian Army to randomly terminate instances and components to ensure applications can withstand infrastructure failures.
3. Chaos engineering involves injecting failures in a controlled way to test recovery capabilities and uncover weaknesses before they impact real users during production outages.
Step by step how to start the Photo Grid configuration, after acquiring a copy of the source code. Illustrated manual, with all the details for you to start your development using Ionic Framework, along with the backend Parse.com.
Kubernates를 위한 Chaos Engineering in Action :: 윤석찬 (AWS 테크에반젤리스트) Channy Yun
Chaos engineering involves intentionally introducing failures into systems to test resilience. It reveals issues that may otherwise remain undetected. Some key aspects of chaos engineering include using tools like Chaos Toolkit and Gremlin to fail components, running experiments at specified times using a configuration file, and introducing faults into service meshes between microservices. The goal is to build confidence in systems by identifying weaknesses before real failures occur.
This document outlines common anti-patterns and challenges the speaker has encountered when working with Node.js, including issues with modules and dependencies, project structure, asynchronous code, error handling, testing, debugging, and deployment. The speaker shares lessons learned and best practices for addressing these problems, such as locking down dependencies, using promises for asynchronous code, and leveraging tools like Nginx, Docker, and logging services to improve debugging and deployment. Overall, the speaker believes Node.js is powerful but asynchronous programming and error handling can be difficult, and the platform is still improving in these areas.
YQL - Christian Heilmann Open Hack London presentationKorben00
YQL (Yahoo Query Language) provides an easy way to access and remix data from various web services using an SQL-like syntax. It has a public REST API that allows querying data without authentication. Developers can also create their own data tables and expose them through YQL. This allows aggregating data from multiple sources into a single query and makes it simple to build prototypes and hacks quickly using existing web APIs and data.
Even when the scope, the budget and the schedule of a project is fixed, there are plenty of dimensions on which you have freedom.
This presentation relates the story of a project that explored some of those other dimensions by adopting various agile aproaches.
(Pecha Kucha version)
WordPress - Whats going on in the server? Herb Miller
A short Show and Tell presentation by Herb Miller, Bobbing Wide outlining his work to analyse the effect of configuration changes on server response times.
First presented at Cheltenham WordPress Meetup ( #WPChelt ) on 31st March 2021
The quantum computers are coming - Karlsruher Entwicklertag 2018Alasdair Collinson
Many people may not know it, but we live in a time where the first quantum computers have been created - and they’re pretty damn cool. Why? Because while regular bits are limited to only two boring values, QBITs can take near infinite values and operate singularly or in harmony with each other. This outstanding property gives rise to a new kind of algorithms (and a lot of fun!). Follow me on a journey from Zuses Z3 computer and Schrödingers cat to supercooled quantum processors and parallel universes - no PhD in physics required.
Similar to Debugging Effectively - All Things Open 2017 (20)
ASCII is so 1963. Nowadays, computers must support a broad range of different characters beyond the 128 we had in the early days of computing - not just accents and emojis but also completely different writing systems used around the globe. The Unicode standard packs a whopping 143,859 characters into an elegant system used by over 95% of the Internet, but PHP's string functions don't play nicely with Unicode by default, making it difficult for developers to properly handle such a wide array of possible user inputs.
In this talk, we'll explore why Unicode is important, how the various encodings like UTF-8 work under-the-hood, how to handle them within PHP, and some nifty tricks and shortcuts to preserve performance.
Releasing High Quality Packages - Longhorn PHP 2021Colin O'Dell
The document provides guidance on creating and maintaining high-quality PHP packages. It discusses defining quality standards, project structure, testing, documentation, releasing packages, and ongoing maintenance. Key aspects include using semantic versioning, writing automated tests, generating documentation, following best practices for code quality, and being responsive to issues and pull requests. The goal is to create packages that are easily installed, well-maintained, and meet community standards.
Releasing High Quality PHP Packages - ConFoo Montreal 2019Colin O'Dell
Releasing open-source libraries is more than sharing your Github URL with the world. There are many considerations and steps involved especially for successful and long-lived projects.
In this talk we’ll cover the principles behind creating, releasing and maintaining high-quality libraries. Topics will include structuring the repository, implementing modern PHP standards, maintaining changelogs, using CI tests, releasing new versions and more.
Automating Deployments with Deployer - php[world] 2018Colin O'Dell
Have you ever botched a deployment and taken a site offline? I have - more times then I'd like to admit. What if we could completely automate the deployment process, make it lightning fast, remove most of the risk, and do it all without custom bash scripts? Better yet, what if we could use the same exact deployment process locally or trigger it via CI? All of this is possible with Deployer - a PHP-based deployment tool which supports virtually every CMS and framework! Attendees will learn the basics of Deployer, how to customize deployments to fit their needs, and how to handle situations if things go wrong.
Releasing open-source libraries involves much more than sharing your Github URL with the world. There are many considerations and steps involved, especially if you want your project to be successful and long-lived. In this talk, we'll cover the principles behind creating, releasing, and maintaining high-quality libraries. Topics will include structuring the repository, implementing modern PHP standards, maintaining changelogs, using CI tests, releasing new versions, and other best practices. Attendees will walk away with enough knowledge to publish their own quality PHP packages on Packagist for others to use.
CommonMark: Markdown Done Right - ZendCon 2017Colin O'Dell
Markdown is one of the most popular markup languages on the web. Unfortunately, with no standard specification, every implementation works differently, producing varying results across different platforms. The CommonMark specification fixes this by providing an unambiguous syntax specification and a comprehensive suite of tests. In this session you'll learn about this standard and how to integrate the league/commonmark parser into their PHP applications. We'll also cover how to customize the library to implement new features like custom Markdown syntax or advanced renderers.
Rise of the Machines: PHP and IoT - ZendCon 2017Colin O'Dell
The Internet of Things (IoT) is fundamentally changing how we interact with the digital world. In this session we’ll explore the implementation of real examples which bridge the gap between the physical and digital world using PHP: asking Alexa for information within a PHP application; displaying API data on an Arduino-powered display; using PHP to control LEDs on a Raspberry Pi to monitor application uptime; and connecting IR sensors to Slack to see whether a conference room is in use.
Hacking Your Way To Better Security - DrupalCon Baltimore 2017Colin O'Dell
This talk educates junior and mid-level developers on common security vulnerabilities, how they are exploited, and how to protect against them. We'll explore several of the OWASP Top 10 attack vectors like SQL injection, XSS, CSRF, and others. Each topic will be approached from the perspective of an attacker to see how these vulnerabilities are detected and exploited using several realistic examples. We'll then apply this knowledge to see how web applications can be secured against such vulnerabilities.
Automating Your Workflow with Gulp.js - php[world] 2016Colin O'Dell
Gulp is a powerful utility for automating development workflows. Tasks are written using code, not configuration, enabling the easy creation of highly-custom and flexible automations. This talk introduces developers to the core concepts of gulp.js, and how to leverage it for new & existing projects. We’ll cover several examples of common tasks for managing CSS, JS and PHP, including: compiling Sass, minifying files, running PHP tests, checking code styles, ensuring legacy browser support & more.
Rise of the Machines: PHP and IoT - php[world] 2016Colin O'Dell
The Internet of Things (IoT) is fundamentally changing how we interact with the digital world. In this talk, we’ll explore the implementation of live examples which bridge the gap between the physical and digital world using PHP: asking Alexa for information on php[world] conference sessions; displaying API data on an Arduino-powered display; using PHP to control LEDs on a Raspberry Pi to monitor application uptime; and connecting IR sensors to Slack to see whether a conference room is in use.
Hacking Your Way to Better Security - ZendCon 2016Colin O'Dell
This document discusses various web application security vulnerabilities like SQL injection and cross-site scripting (XSS) from the perspective of an attacker. It begins by introducing SQL injection and demonstrates how it can be used to extract hidden data like usernames and credit card numbers. It then covers XSS and how malicious scripts can be injected onto a page to hijack user sessions. Finally, it discusses ways to protect against these vulnerabilities like input filtering, output encoding, and prepared statements. The overall goal is to help understand common attacks and how to build more secure applications.
Hacking Your Way to Better Security - PHP South Africa 2016Colin O'Dell
This talk educates developers on common security vulnerabilities, how they are exploited, and how to protect against them. We'll explore several of the OWASP Top 10 attack vectors like SQL injection, XSS, CSRF, and more. Each topic will be approached from the perspective of an attacker to see how these vulnerabilities are detected and exploited using several realistic examples. We'll then apply this knowledge to see how web applications can be secured against such vulnerabilities.
CommonMark: Markdown done right - Nomad PHP September 2016Colin O'Dell
Markdown is one of the most popular markup languages on the Web. Unfortunately, with no standard specification, every implementation works differently, producing varying results across different platforms. The CommonMark specification fixes this by providing an unambiguous syntax specification and a comprehensive suite of tests. Attendees will learn about this standard and how to integrate the league/commonmark parser into their applications. We will also cover how to add new syntax and other features to the parser to fit your custom needs.
Hacking Your Way To Better Security - Dutch PHP Conference 2016Colin O'Dell
The goal of this talk is to educate developers on common security vulnerabilities, how they are exploited, and how to protect against them. We'll explore several of the OWASP Top 10 attack vectors like SQL injection, XSS, CSRF, session hijacking, and insecure direct object references. Each topic will be approached from the perspective of an attacker to see how these vulnerabilities are detected and exploited using several realistic examples. Once we've established an understanding of how these attacks work, we'll look at concrete steps you can take to secure web applications against such vulnerabilities. The knowledge gained from this talk can also be used for participating in "Capture the Flag" security competitions.
Hacking Your Way To Better Security - php[tek] 2016Colin O'Dell
This talk educates developers on common security vulnerabilities, how they are exploited, and how to protect against them. We will explore several of the OWASP top 10 attack vectors, such as SQL injection, XSS, CSRF, and session hijacking. Each topic will be approached from the perspective of an attacker to learn how these vulnerabilities are detected and exploited using several realistic examples. We will then apply this knowledge to learn how web applications can be secured against such vulnerabilities.
Markdown is one of the most popular markup languages on the Web. Unfortunately, with no standard specification, every implementation works differently, producing varying results across different platforms. The CommonMark specification fixes this by providing an unambiguous syntax specification and a comprehensive suite of tests. Attendees will learn about this standard and how to integrate the league/commonmark parser into their applications. We will also cover how to add new custom features.
The document provides an overview of new features, changes, deprecations, and removals in PHP 7, as well as how to install PHP 7. Key points covered include:
1. New features such as scalar type hints, return type declarations, the spaceship operator, null coalesce operator, and anonymous classes.
2. Changes like improved performance, uniform variable syntax, semi-reserved keywords, and exceptions being thrown for fatal errors.
3. Deprecated features such as PHP 4 constructors and the salt option for password_hash.
4. Removed features like alternative PHP tags and the date.timezone warning.
5. Installing PHP 7 via packages, compiling from source, or
The goal of this talk is to educate developers on common security vulnerabilities, how they are exploited, and how to protect against them. We'll explore several of the OWASP Top 10 attack vectors like SQL injection, XSS, CSRF, session hijacking, and insecure direct object references. Each topic will be approached from the perspective of an attacker to see how these vulnerabilities are detected and exploited using several realistic examples. Once we've established an understanding of how these attacks work, we'll look at concrete steps you can take to secure web applications against such vulnerabilities. The knowledge gained from this talk can also be used for participating in "Capture the Flag" security competitions.
league/commonmark is a well-written, super-configurable Markdown parser for PHP based on the CommonMark spec. In this lightning talk, we'll introduce the CommonMark spec, discuss why it's important, and demonstrate how the league/commonmark project can be used and extended for your own PHP projects
The PHP 7 release is just around the corner, bringing some much-desired changes and improvements to the language. However, many developers simply aren't aware of what's coming. We'll remedy this by checking out the new "spaceship operator," demonstrating how static type hints produce clean code, and using anonymous classes to quickly implement interfaces on the fly. Attendees will also learn about breaking changes and "gotchas" to watch out for when making the upgrade and will receive pointers on getting started with PHP 7 today.
Sami provided a beginner-friendly introduction to Amazon Web Services (AWS), covering essential terms, products, and services for cloud deployment. Participants explored AWS' latest Gen AI offerings, making it accessible for those starting their cloud journey or integrating AI into coding practices.
Seamless PostgreSQL to Snowflake Data Transfer in 8 Simple StepsEstuary Flow
Unlock the full potential of your data by effortlessly migrating from PostgreSQL to Snowflake, the leading cloud data warehouse. This comprehensive guide presents an easy-to-follow 8-step process using Estuary Flow, an open-source data operations platform designed to simplify data pipelines.
Discover how to seamlessly transfer your PostgreSQL data to Snowflake, leveraging Estuary Flow's intuitive interface and powerful real-time replication capabilities. Harness the power of both platforms to create a robust data ecosystem that drives business intelligence, analytics, and data-driven decision-making.
Key Takeaways:
1. Effortless Migration: Learn how to migrate your PostgreSQL data to Snowflake in 8 simple steps, even with limited technical expertise.
2. Real-Time Insights: Achieve near-instantaneous data syncing for up-to-the-minute analytics and reporting.
3. Cost-Effective Solution: Lower your total cost of ownership (TCO) with Estuary Flow's efficient and scalable architecture.
4. Seamless Integration: Combine the strengths of PostgreSQL's transactional power with Snowflake's cloud-native scalability and data warehousing features.
Don't miss out on this opportunity to unlock the full potential of your data. Read & Download this comprehensive guide now and embark on a seamless data journey from PostgreSQL to Snowflake with Estuary Flow!
Try it Free: https://dashboard.estuary.dev/register
Software development... for all? (keynote at ICSOFT'2024)miso_uam
Our world runs on software. It governs all major aspects of our life. It is an enabler for research and innovation, and is critical for business competitivity. Traditional software engineering techniques have achieved high effectiveness, but still may fall short on delivering software at the accelerated pace and with the increasing quality that future scenarios will require.
To attack this issue, some software paradigms raise the automation of software development via higher levels of abstraction through domain-specific languages (e.g., in model-driven engineering) and empowering non-professional developers with the possibility to build their own software (e.g., in low-code development approaches). In a software-demanding world, this is an attractive possibility, and perhaps -- paraphrasing Andy Warhol -- "in the future, everyone will be a developer for 15 minutes". However, to make this possible, methods are required to tweak languages to their context of use (crucial given the diversity of backgrounds and purposes), and the assistance to developers throughout the development process (especially critical for non-professionals).
In this keynote talk at ICSOFT'2024 I presented enabling techniques for this vision, supporting the creation of families of domain-specific languages, their adaptation to the usage context; and the augmentation of low-code environments with assistants and recommender systems to guide developers (professional or not) in the development process.
Ansys Mechanical enables you to solve complex structural engineering problems and make better, faster design decisions. With the finite element analysis (FEA) solvers available in the suite, you can customize and automate solutions for your structural mechanics problems and parameterize them to analyze multiple design scenarios. Ansys Mechanical is a dynamic tool that has a complete range of analysis tools.
A captivating AI chatbot PowerPoint presentation is made with a striking backdrop in order to attract a wider audience. Select this template featuring several AI chatbot visuals to boost audience engagement and spontaneity. With the aid of this multi-colored template, you may make a compelling presentation and get extra bonuses. To easily elucidate your ideas, choose a typeface with vibrant colors. You can include your data regarding utilizing the chatbot methodology to the remaining half of the template.
AI Chatbot Development – A Comprehensive Guide .pdfayushiqss
Discover how generative AI is transforming IT development in this blog. Learn how using AI software development, artificial intelligence tools, and generative AI tools can lead to smarter, faster, and more efficient software creation. Explore real-world applications and see how these technologies are driving innovation and cutting costs in IT development.
2. Photo by Joseph B // cc by-nc-nd 2.0 // https://flic.kr/p/7GAMBe
Colin O’Dell
• Lead Web Developer at Unleashed Technologies
• Primary language is PHP
• PHP developer for 15 years
• PHP League Leadership Team
• Author/maintainer of PHP CommonMark library
• PHP 7 Upgrade Guide e-book author
• Also experienced in JavaScript, Java, C#, and Python
@colinodell
3. Overview
I. Importance of debugging
II. Debugging process
III. Tools & Techniques
IV. Q&A
Photo by Roman Boed // cc by 2.0 // https://flic.kr/p/ngwcf1
@colinodell
5. Debugging is...
Photo by Ewan Cross // cc by-nc-nd 2.0 // https://flic.kr/p/7MCt3m
important
@colinodell
6. Debugging is...
Photo by Ewan Cross // cc by-nc-nd 2.0 // https://flic.kr/p/7MCt3m
the single most
important skill in
programming.
@colinodell
7. Photo by florianric // cc by 2.0 // https://flic.kr/p/c4QJzC
PlanningCoding
@colinodell
8. Photo by florianric // cc by 2.0 // https://flic.kr/p/c4QJzC
Planning
Testing &
Debugging
Coding
@colinodell
9. Debugging is the process of finding and resolving bugs
or defects that prevent correct operation of computer
software or a system.
– Wikipedia
Photo by Stephen Dyrgas // cc by-nc-nd 2.0 // https://flic.kr/p/3eTfWU
10. Process is the foundation of effective debugging
Process
Photo by Matthew Paulson // cc by-nc-nd 2.0 // https://flic.kr/p/di35xa
11. Photo by Matthew Paulson // cc by-nc-nd 2.0 // https://flic.kr/p/di35xa
Gain experience with code and tools
Experience
Process
12. Photo by Matthew Paulson // cc by-nc-nd 2.0 // https://flic.kr/p/di35xa
Develop your intuition
Intuition
Experience
Process
13. Junior Developers
• Try the “usual” steps
• Clear caches
• Re-install dependencies
• chmod –R 777 *
• Ask somebody else
• Co-worker
• Google
• StackOverflow post
Photo by Yoel Ben-Avraham, with changes // cc by--nd 2.0 // https://flic.kr/p/6pmtQL
@colinodell
14. XY Problem
Photo by Yoel Ben-Avraham, with changes // cc by--nd 2.0 // https://flic.kr/p/6pmtQL
•I want to solve problem X
•How do I solve X?
@colinodell
15. XY Problem
Photo by Yoel Ben-Avraham, with changes // cc by--nd 2.0 // https://flic.kr/p/6pmtQL
•I want to solve problem X
•How do I solve X?
•Solution Y might work
•How can I do Y?
@colinodell
16. Photo by quattrostagioni // cc by 2.0 // https://flic.kr/p/aGjVq8
1.Don’t parse HTML with regex
2.Solve problems the right way @colinodell
17. “I don’t know why”
“For some reason”
“Doesn’t make sense”
Photo by Stanley Yuu // cc by-nc-nd 2.0 // https://flic.kr/p/pMnfNu
@colinodell
19. “The bug is not moving around in your code,
trying to trick or evade you. It is just siting in
one place, doing the wrong thing in the same
way every time.” – Nick Parlante, Debugging Zen
Photo by GrahamC57 // cc by-nc-nd 2.0 // https://flic.kr/p/cwJi9Q
@colinodell
20. Assume your
code is the
problem
Photo by Sergio Flores Rosales // cc by-nc-nd 2.0 // https://flic.kr/p/5UHkaW
@colinodell
21. Systematic Approach
1. Gather information
2. Replicate the issue
3. Identify the culprit
4. Fix it & re-test
5. Mitigate future occurrences
Photo from EduSpiral // cc by-nc-nd 3.0
@colinodell
22. 1. Gather information
• Expected behavior vs.
actual behavior
• Error messages
• Stack traces
Photo from youmustdesireit.wordpress.com
•Screenshots
•Browser & OS
•Date & time
•Log entries
@colinodell
23. 2. Replicate the Issue
Be able to replicate with 100% certainty
Photo by Nick Royer // cc by-sa // https://flic.kr/p/d41ASC
@colinodell
24. 3. Identify the Culprit
Photo by U.S. Navy // cc 2.0 // https://flic.kr/p/n6Wgks
• Be methodical
• Make no assumptions
• Understand the bug @colinodell
25. 4. Fix it & Re-test
• Attempt to replicate again
• Avoid XY problem
• No temporary workarounds!
• Add technical debt
• May introduce other issues
• Never get replaced with true solutions
Photo by Jeff Eaton // cc by-sa 2.0 // https://flic.kr/p/b33rSx
@colinodell
26. 5. Mitigate Future Occurrences
• Add an automated test
• Share your new knowledge
• Project documentation
• Blog post
• StackOverflow
• Submit patch upstream
Photo by marcokalmann // cc by-nc-nd 2.0 // https://flic.kr/p/4CqLMQ
@colinodell
27. Recap
1. Gather information
2. Replicate the issue
3. Identify the culprit
4. Fix it & re-test
5. Mitigate future occurrences
Photo from EduSpiral // cc by-nc-nd 3.0
@colinodell
28. Long-Term Results
• Gain experience
• Learn how the system works
• Build heuristics
• Boost confidence
Photo by Glenn Beltz // cc by 2.0 // https://flic.kr/p/i7Csdx
@colinodell
30. Two essential tools
• Integrated development
environment (IDE)
• Interactive debugger
Photo by florianric // cc by 2.0 // https://flic.kr/p/c4QJzC
@colinodell
31. Integrated Development Environment
•Minimum features:
•Syntax highlighting
•Auto-completion
•Fast code navigation
•Debugger
Photo by florianric // cc by 2.0 // https://flic.kr/p/c4QJzC
@colinodell
32. Interactive Debugger
•Pause code execution
•Step through execution
•Examine variables
•Explore call stack
Photo by florianric // cc by 2.0 // https://flic.kr/p/c4QJzC
@colinodell
33. Techniques
1. Trace backwards from known issue
2. Trace forwards from start
3. Binary search
4. Use tools
5. Get help
6. Take a break
Photo by Massmo Relsig // cc by-nc-nd 2.0 // https://flic.kr/p/pFrJCe
@colinodell
34. 1. Trace backwards
•Error is thrown from known location
•Use a debugger
•Establish context
•Work backwards
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
@colinodell
35. 1. Trace backwards
•Error is thrown from known location
•Use a debugger
•Establish context
•Work backwards
a()
b()
c()
d()
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
36. 1. Trace backwards
•Error is thrown from known location
•Use a debugger
•Establish context
•Work backwards
a()
b()
c()
d()
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
37. 1. Trace backwards
•Error is thrown from known location
•Use a debugger
•Establish context
•Work backwards
a()
b()
c()
d()
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
38. 1. Trace backwards
•Error is thrown from known location
•Use a debugger
•Establish context
•Work backwards
a()
b()
c()
d()
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
39. 1. Trace backwards
•Error is thrown from known location
•Use a debugger
•Establish context
•Work backwards
a()
b()
c()
d()
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
40. 2. Trace forwards
•Opposite direction
•Problematic line
isn’t known
•Use debugger or logging
a()
b()
c()
d()
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
41. 2. Trace forwards
•Opposite direction
•Problematic line
isn’t known
•Use debugger or logging
a()
b()
c()
d()
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
42. 2. Trace forwards
•Opposite direction
•Problematic line
isn’t known
•Use debugger or logging
a()
b()
c()
d()
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
43. 2. Trace forwards
•Opposite direction
•Problematic line
isn’t known
•Use debugger or logging
a()
b()
c()
d()
Photo by Shawn Harquail // cc by-nc 2.0 // https://flic.kr/p/npxFVw
44. 3. Divide & Conquer
• Identify different code sections
• Set breakpoints at the boundaries
• Isolate issue to one particular area
• Focus efforts on that area
@colinodell
50. 4. Use tools
•Variable dumps
•Debug toolbars
•Console utility
•Profilers
•git bisect
•netcat
•curl
•strace
•etc.
Photo by florianric // cc by 2.0 // https://flic.kr/p/c4QJzC
@colinodell
51. Variable dumps
Photo by Joseph B // cc by-nc-nd 2.0 // https://flic.kr/p/7GAMBe
•Print to output:
•var_dump()
•pprint()
•puts()
•Log to file
•file_put_contents()
•Logger.debug()
@colinodell
52. Photo by Joseph B // cc by-nc-nd 2.0 // https://flic.kr/p/7GAMBe
Debug toolbars
@colinodell
53. Photo by Joseph B // cc by-nc-nd 2.0 // https://flic.kr/p/7GAMBe
Console Utility
Symfony: bin/console
Laravel: artisan
Drupal: drush
Drupal Console
Magento: n98-magerun
@colinodell
54. Performance Profiling
Identify slowness:
• Bottlenecks
• Resource hogs
• Inefficient code
Photo by Alan Stark // cc by-sa 2.0 // https://flic.kr/p/dn3qjx
Tools:
• Blackfire (freemium)
• New Relic (freemium)
• xhprof (open-source)
@colinodell
55. git bisect
v1.7 ? ? ? ? ? ? ? HEAD
Photo by unbekannt270 // cc by 2.0 // https://flic.kr/p/oHReqm
@colinodell
56. git bisect
v1.7 ? ? ? ? ? ? ? HEAD
Photo by unbekannt270 // cc by 2.0 // https://flic.kr/p/oHReqm
@colinodell
57. git bisect
v1.7 ? ? ? BAD ? ? ? HEAD
Photo by unbekannt270 // cc by 2.0 // https://flic.kr/p/oHReqm
@colinodell
58. git bisect
v1.7 ? ? ? BAD BAD BAD BAD HEAD
Photo by unbekannt270 // cc by 2.0 // https://flic.kr/p/oHReqm
@colinodell
59. git bisect
v1.7 ? GOOD ? BAD BAD BAD BAD HEAD
Photo by unbekannt270 // cc by 2.0 // https://flic.kr/p/oHReqm
@colinodell
60. git bisect
v1.7 GOOD GOOD ? BAD BAD BAD BAD HEAD
Photo by unbekannt270 // cc by 2.0 // https://flic.kr/p/oHReqm
@colinodell
61. git bisect
v1.7 GOOD GOOD
X BAD BAD BAD BAD HEAD
Photo by unbekannt270 // cc by 2.0 // https://flic.kr/p/oHReqm
abcd123 is the first bad commit
@colinodell
62. git bisect
Photo by unbekannt270 // cc by 2.0 // https://flic.kr/p/oHReqm
@colinodell
# of Commits # of Tests
9 4
90 8
900 16
Scales logarithmically – runs in O(log N)
63. Photo by Joseph B // cc by-nc-nd 2.0 // https://flic.kr/p/7GAMBe
netcat
@colinodell
64. Photo by Joseph B // cc by-nc-nd 2.0 // https://flic.kr/p/7GAMBe
strace
@colinodell
65. 5. Get help
• RTFM / RTFD
• Project forums or issue queue
• StackOverflow, IRC, etc.
• Ask a colleague
• Expert in that area
• Senior developer
• Rubber ducking
Photo by Hiromitsu Morimoto // cc by-sa 2.0 // https://flic.kr/p/6Vzzaa
@colinodell
66. 6. Take a break
Photo by Kristina Alexadnerson // cc by-nc-nd 2.0 // https://flic.kr/p/cFEcDC
• Clear your mind; start fresh
• Forget invalid assumptions
• Recharge your batteries
• Let your subconscious work on it
@colinodell
67. Four things to walk away with
1. Computers aren’t random,
and neither are bugs
2. Persistence will always pay off
3. Don’t be afraid to dive deep
4. Don’t make assumptions or
take things for granted
Photo by Kristina Alexadnerson // cc by-nc-nd 2.0 // https://flic.kr/p/dvEpfY
@colinodell
According to the Mythical Man Month, 1/6th
½ is testing/debugging
How much - actually writing code vs getting it working
Area where it’s worthwhile to become efficient
READ SLOWLY
Shouldn’t be done haphazardly
Like intuition, but not
Understanding without proof
Clarity; accuracy; precision
--
Focus on the process
Experience and “sixth sense” will come with time
NEXT: Debugging process
BE NICE / CONSTRUCTIVE
TODO ADD NOTES
When you give up on the proper approach
Apply workaround instead
Improper solutions will cause issues later
NEXT - EXAMPLE
Base85-encoded
Don’t be clever
TRANSITION NEEDED!!
Magical thinking
Article
sneaky
Bugs are almost always based on faulty assumptions
95% in your code
If helping others, assume their code is problem
Challenge their assumptions
Take with grain of salt
Define the symptoms
Collect everything you can
Automated tests preferred, but manual is okay too
LEGOS
Understand the fundamental nature
Exactly why
Other nice-to-haves:
File syncing
Git integration
Run tools
PhpStorm, Sublime Text, vim
NOT Notepad++ or Dreamweaver
Debuggers are awesome tool
…
Better than primitive approaches
Examine in real time
Xdebug
Chrome developer tools
Click 4 times
Dive in
Look at call stack
Advanced breakpoints
Grouping
Conditions
Stack trace
Grep for error message
Set breakpoint
For example
Examine variables
How did I get here? – call stack
Log/output results at different steps
Identify where things start going wrong
Log/output results at different steps
Identify where things start going wrong
Log/output results at different steps
Identify where things start going wrong
Log/output results at different steps
Identify where things start going wrong
Debugger is critical
Not only tool
Tools are not a substitute for thinking