PHX Session #3 - "It Works on My Machine!" Closing the Loop Between Development & Testing
•Download as PPTX, PDF•
0 likes•600 views
The document discusses closing the loop between development and testing. It emphasizes that quality is a shared responsibility of both developers and testers. Effective communication between these teams is important, and automation can help reduce manual testing effort. The document argues that by working together and applying lessons learned through each iteration, development and testing teams can improve their process and deliver high quality software.
Report
Share
Report
Share
Recommended
PHX - Session #2 Test Driven Development: Improving .NET Application Performa...
This document discusses test driven development (TDD) and its benefits. TDD focuses on designing tests before writing code to ensure requirements are met. It advocates writing automated unit tests that isolate and test individual operations. TDD follows a "Red, Green, Refactor" process of writing a failing test, making it pass with minimal code, then refactoring. Benefits of TDD include improved code quality, fewer bugs, and faster development cycles.
Test Driven Development
This document discusses test-driven development (TDD) and unit testing. It defines TDD as a process that involves writing a failing test first, then implementing code to pass that test, and refactoring if needed. Key benefits of TDD and unit testing include reduced bugs, lower maintenance costs, and improved code design. The document provides guidelines for writing good unit tests and emphasizes that tests should be quick, isolated, and answer what behavior was tested and what the expected and actual results were.
Unit testing for project managers
This presentation gives you the evidence as to why unit testing works and a process for how to bring it your team as soon as possible. There's a reason why the growth of unit testing, and automated unit testing in particular, has exploded over the past few years. It not only improves your code, it's faster than releasing code without tests. You'll learn: What, exactly, is a unit test?; The 7 reasons why managers love unit testing; and how to change mindset and processes to start unit testing now.
Agile and test driven development
The document provides an overview of agile and test-driven development. It begins by comparing waterfall and agile approaches, noting that agile uses short iterative cycles. It then defines agile as iterative and incremental, with continual revisiting of requirements and design. Common agile methodologies like Scrum and extreme programming are discussed. Test-driven development is introduced as writing tests before code to ensure requirements are met and prevent bugs. The benefits of agile and TDD for developers are more code proven to meet requirements and less time spent debugging.
Test Driven Development (TDD) & Continuous Integration (CI)
Sebuah pembahasan menarik tentang Agile Software Development dengan Test Driven Development (TDD) & Continuous Integration (CI). Materi ini disusun oleh Mas Disyam
Understanding Scrum
This document provides an overview and introduction to Agile and Scrum concepts. It discusses what Agile is and its values and principles like test-driven development. It also describes Scrum roles like Product Owner and Scrum Master, events like the daily scrum and sprint planning, and artifacts like the product backlog. The document summarizes Scrum practices for requirements gathering, estimation, the definition of done, backlog refinement, and retrospectives. It also briefly touches on topics like cross-functional teams, team formation models, and conditions for high performing teams.
Test driven development_continuous_integration
This document discusses test-driven development (TDD) and continuous integration (CI). It explains that TDD involves writing tests before code to drive the design. The key steps of TDD are design, test, implement, and test again. CI involves integrating code changes frequently, usually daily, to catch errors early. TDD and CI work well together as the tests from TDD can be run automatically through CI to provide rapid feedback. The document provides an overview of how to implement TDD and CI using tools like Jenkins.
Understanding Kanban
Nikos Batsios presents an overview of Kanban principles and practices for managing workflow, including visualizing work, limiting work-in-process, and managing flow. Key aspects covered are using a Kanban board to visualize workflow stages and work items, establishing work-in-process limits to improve throughput, addressing bottlenecks, and helping work flow through the system by reducing waste and handoffs between stages. Metrics like throughput are also discussed. The presentation provides examples and recommendations for applying Kanban principles to optimize an organization's workflow.
Recommended
PHX - Session #2 Test Driven Development: Improving .NET Application Performa...
This document discusses test driven development (TDD) and its benefits. TDD focuses on designing tests before writing code to ensure requirements are met. It advocates writing automated unit tests that isolate and test individual operations. TDD follows a "Red, Green, Refactor" process of writing a failing test, making it pass with minimal code, then refactoring. Benefits of TDD include improved code quality, fewer bugs, and faster development cycles.
Test Driven Development
This document discusses test-driven development (TDD) and unit testing. It defines TDD as a process that involves writing a failing test first, then implementing code to pass that test, and refactoring if needed. Key benefits of TDD and unit testing include reduced bugs, lower maintenance costs, and improved code design. The document provides guidelines for writing good unit tests and emphasizes that tests should be quick, isolated, and answer what behavior was tested and what the expected and actual results were.
Unit testing for project managers
This presentation gives you the evidence as to why unit testing works and a process for how to bring it your team as soon as possible. There's a reason why the growth of unit testing, and automated unit testing in particular, has exploded over the past few years. It not only improves your code, it's faster than releasing code without tests. You'll learn: What, exactly, is a unit test?; The 7 reasons why managers love unit testing; and how to change mindset and processes to start unit testing now.
Agile and test driven development
The document provides an overview of agile and test-driven development. It begins by comparing waterfall and agile approaches, noting that agile uses short iterative cycles. It then defines agile as iterative and incremental, with continual revisiting of requirements and design. Common agile methodologies like Scrum and extreme programming are discussed. Test-driven development is introduced as writing tests before code to ensure requirements are met and prevent bugs. The benefits of agile and TDD for developers are more code proven to meet requirements and less time spent debugging.
Test Driven Development (TDD) & Continuous Integration (CI)
Sebuah pembahasan menarik tentang Agile Software Development dengan Test Driven Development (TDD) & Continuous Integration (CI). Materi ini disusun oleh Mas Disyam
Understanding Scrum
This document provides an overview and introduction to Agile and Scrum concepts. It discusses what Agile is and its values and principles like test-driven development. It also describes Scrum roles like Product Owner and Scrum Master, events like the daily scrum and sprint planning, and artifacts like the product backlog. The document summarizes Scrum practices for requirements gathering, estimation, the definition of done, backlog refinement, and retrospectives. It also briefly touches on topics like cross-functional teams, team formation models, and conditions for high performing teams.
Test driven development_continuous_integration
This document discusses test-driven development (TDD) and continuous integration (CI). It explains that TDD involves writing tests before code to drive the design. The key steps of TDD are design, test, implement, and test again. CI involves integrating code changes frequently, usually daily, to catch errors early. TDD and CI work well together as the tests from TDD can be run automatically through CI to provide rapid feedback. The document provides an overview of how to implement TDD and CI using tools like Jenkins.
Understanding Kanban
Nikos Batsios presents an overview of Kanban principles and practices for managing workflow, including visualizing work, limiting work-in-process, and managing flow. Key aspects covered are using a Kanban board to visualize workflow stages and work items, establishing work-in-process limits to improve throughput, addressing bottlenecks, and helping work flow through the system by reducing waste and handoffs between stages. Metrics like throughput are also discussed. The presentation provides examples and recommendations for applying Kanban principles to optimize an organization's workflow.
Test-Driven Development
Test-driven development (TDD) is a software development process that relies on the repetition of a short development cycle of requirements, design, and coding. It promotes writing tests before writing code (test-first design) and helps improve code quality by reducing defects. The TDD cycle involves writing an automated test, running the test and seeing it fail, writing the minimum amount of code to pass the test, and refactoring the code as needed. TDD brings benefits like clarifying requirements, adding executable documentation, and detecting errors early. Acceptance TDD involves automating acceptance tests to define and validate requirements. It helps establish a definition of done and improves team collaboration.
Performance Metrics for your Delivery Pipeline - Wolfgang Gottesheim
The document discusses the importance of measuring performance metrics throughout the software development lifecycle from testing to production. It argues that performance should be a quality gate for software releases. Key points made include that unit and integration tests could measure performance metrics; acceptance and load tests are important for performance but are later in the cycle; and performance should be incorporated into continuous delivery processes with automated collection and analysis of metrics across builds.
From Gatekeeper to Partner by Kelsey Shannahan
The document discusses moving from a "gatekeeper" model of testing, where testing is done separately after development, to a "partner" model where testing is integrated into development and shared responsibility of the team. It provides tips for making this transition, such as fixing problems developers experience with testing, integrating testing into development workflows, and helping testers contribute to other parts of development to become true partners. The overall message is that testing is most effective when it is easy to do and an inherent part of the development process done collaboratively by the entire team.
Agileee 2012
The document discusses reversing the "tests pyramid" approach to address technical debt in legacy code. It notes that unit testing is difficult for code without separation of concerns, but refactoring without tests is risky. It proposes starting with high-level tests to gain confidence for refactoring into units and writing unit tests incrementally. However, end-to-end tests are long to maintain, and if needed, the architecture may be flawed. Reversing the tests pyramid and refactoring code in this way takes time but pays back technical debt and allows for sustainable changes. Beware of refactoring just for its own sake - focus on removing duplication and improving changeability.
Creating test stability to create continuous delivery
Trisha Chetani discusses her experience transforming automated tests at Visenze from being slow and flaky to stable to enable continuous delivery. She analyzed the root causes of flakiness, which included changing locators, flows, and application slowness. Through coding best practices, team responsibility, stable environments, skills development, product testability improvements, and continuous learning, she was able to reduce test execution time from 30 to 5 minutes and maintain a stable pipeline.
A Concise QA Process
This document summarizes a concise QA and testing process developed for a small startup. It includes protocols for building, testing, managing changes, and releasing software. The build protocol ensures testing receives builds and information about changes. The test cycle protocol defines different types of testing cycles. The change protocol establishes feature freezes and code freezes to control changes late in development. The release protocol details the release approval and packaging process.
Implementing Agile : Do's and Don'ts
The document discusses dos and don'ts for implementing agile practices. It provides examples of both ideal (Teams A and B) and non-ideal (Teams C, D, and E) ways that teams have implemented agile. Some key dos included allowing the entire team to communicate with clients, following test-driven development and continuous integration practices, and automating deployment. Don'ts included micro-managing teams, relying too heavily on documentation over working software, and forming specialized subgroups within teams. The document emphasizes learning from mistakes and experiences to continuously improve agile implementation.
Arguments in favor of a progressive software rewrite
Arguments in favor of a progressive software rewrite .
Blog post here : https://sylvainleroy.com/2018/06/18/to-rewrite-or-not-to-rewrite-a-software/
It's a presentation about why software should be preserved and .
Written and adapted for Byoskill.
Byoskill.com
Test Driven Development
Testing is not something that traditional PHP developers are being familiar with. This session introduces the needs and means for testing, and the test-driven development model to create rock-solid PHP applications.
Examples how to move towards Zero Defects
This document provides an overview of approaches to achieving zero defects in software development. It discusses how adopting a "zero defects" attitude can reduce defects by 50% overnight. It emphasizes defect prevention through proper root cause analysis and design reviews over testing. Iterative design, implementation, and review cycles are recommended to find and address issues early. The goal of quality assurance is to help developers produce fewer defects by focusing on prevention rather than finding defects after the fact. The ultimate goal is to deliver working software to customers with "no questions and no issues."
B. Durrett The Challenges of Continuous Deployment Social Developer Summit
The document discusses continuous deployment, where code is deployed to production within 20 minutes of being committed. The author details how IMVU, a social media company, successfully uses this approach, deploying code up to 50 times per day. Some benefits are regressions are easy to find and fix, and releases have zero overhead. Challenges include outages, new testing needs, and increased coordination as the engineering team grows. Overall, the author argues that continuous deployment scales well and is a key part of a good development process.
Put "fast" back in "fast feedback"
One of the cornerstones in Agile development is fast feedback. For engineering, "fast" means "instantly" or "in 5 minutes", not "tomorrow" or "this week". Your engineering practices should ensure that you can answer yes to most of the following questions:
- Do we get all test results in less than 5 minutes after a commit?
- Is our code coverage more than 75% for both front-end and back-end?
- Can we start exploratory testing in less than 15 minutes after a commit?
- Do all our tests pass more than 90% of our commits?
This talk will give you practical advice on how to get to "yes, we get fast feedback".
Keynote AST 2016
The document discusses various aspects of automating software testing. It suggests automating the detection of flaky tests, determining the severity of test failures, converting tests to more isolated unit tests, and using usage data to determine what to test next. It emphasizes that while automation can improve testing efficiency, human oversight is still needed, and code reviews serve as the link between automated and manual processes.
Test pyramid
The document discusses different types of software tests including unit tests, integration tests, service tests, and UI end-to-end tests. Unit tests check individual components, integration tests verify communication between components, service tests validate API requests and responses, and UI end-to-end tests simulate user interactions to check the full application. The document also provides an example of a student result service test response.
Why Automated Testing Matters To DevOps
“Automated testing is a pain in my ear! Why can’t QA get it right? Why do the tests keep breaking? And for Pete’s sake, stop blaming the infrastructure!”
…Ok, maybe you chose a different word than “ear”.
How often do you have thoughts like this? Daily?
Let’s talk about these frustrations, why they exist and how we can use them to improve our systems!
In this talk, Paul Merrill, founder and Principal Automation Engineer at Beaufort Fairmont explores why automated testing matters to DevOps. Join us to learn how automated testing can be a useful tool in the creation and release of your systems!
Optimizing Your Agile Testing Processes
An overview of agile testing and how to incorporate it into an agile software development process.
From a Webinar by uTest: http://www.utest.com/webinar_agile_testing.htm
Test driven development
This document discusses Test Driven Development (TDD). TDD helps create clean, simple code designs with low coupling between components. Writing tests first allows developing code with confidence as tests accumulate. It helps avoid technical debt by refactoring code as needed. TDD produces documentation in the form of executable tests and enables continuous integration and delivery. The TDD process follows the "Red-Green-Refactor" mantra of writing a failing test first, then code to pass the test, and refactoring code as needed. Tests should be written to be fast, independent, repeatable, self-validating, and timely. Tools and coding dojos can help practice and improve TDD skills.
Testing in java
Testing in Java discusses different types of software tests including unit tests, integration tests, and automation tests. It outlines the benefits of testing such as better code quality, fewer bugs, and more reliable software. Various Java testing tools and frameworks are also introduced like JUnit, Mockito, and PowerMock. Sample test code is demonstrated using annotations and assertions to validate expected outcomes.
Test Driven Development
Test Driven Development (TDD) provides several benefits over traditional waterfall and iterative development models:
1) It establishes a fast feedback cycle between writing code and writing tests, allowing developers to quickly validate functionality.
2) The automated tests that are written serve as documentation and specifications for the code, giving confidence that changes don't break existing functionality.
3) High test coverage promotes well-designed, loosely-coupled code that is easier to maintain and extend over time.
Automation testing in Agile project
The document summarizes best practices for test automation, including:
- Unit tests should be automated as the first step and follow naming conventions.
- Integration and performance tests require grouping, isolation, and handling test data issues.
- UI tests can be automated with Selenium and integrated into the build pipeline.
- Automated test data, code, and plan generation may be useful once a project's structure stabilizes.
- Automation aims to provide transparency, improve skills, and reduce manual work over time through a smarter approach.
Building Scalable .NET Apps
Guy Nirpaz is the EVP of R&D at GigaSpaces Technologies. He has experience with several startups in designing and architecting complex systems. GigaSpaces provides a scale-out platform optimized for distributed environments that can handle unpredictable demand through linear and dynamic scalability. Traditional tier-based architectures are not scalable as they rely on centralized resources. The presentation explores building scalable applications by addressing the limitations of fundamental architectures and proposing cost-effective alternatives like caching, partitioning, and dynamic scaling based on SLAs.
Performance Tuning of .NET Application
This document discusses performance tuning of .NET applications. It begins by defining performance tuning as improving system performance. It then discusses identifying bottlenecks through profiling, such as by using dotTrace and dotMemory tools. Various ways to optimize performance are covered, such as choosing appropriate collections, making applications parallel as needed, and managing memory efficiently by reducing allocation and using value types and IDisposable patterns. The document aims to provide guidance on optimizing .NET applications through measurement and profiling.
More Related Content
What's hot
Test-Driven Development
Test-driven development (TDD) is a software development process that relies on the repetition of a short development cycle of requirements, design, and coding. It promotes writing tests before writing code (test-first design) and helps improve code quality by reducing defects. The TDD cycle involves writing an automated test, running the test and seeing it fail, writing the minimum amount of code to pass the test, and refactoring the code as needed. TDD brings benefits like clarifying requirements, adding executable documentation, and detecting errors early. Acceptance TDD involves automating acceptance tests to define and validate requirements. It helps establish a definition of done and improves team collaboration.
Performance Metrics for your Delivery Pipeline - Wolfgang Gottesheim
The document discusses the importance of measuring performance metrics throughout the software development lifecycle from testing to production. It argues that performance should be a quality gate for software releases. Key points made include that unit and integration tests could measure performance metrics; acceptance and load tests are important for performance but are later in the cycle; and performance should be incorporated into continuous delivery processes with automated collection and analysis of metrics across builds.
From Gatekeeper to Partner by Kelsey Shannahan
The document discusses moving from a "gatekeeper" model of testing, where testing is done separately after development, to a "partner" model where testing is integrated into development and shared responsibility of the team. It provides tips for making this transition, such as fixing problems developers experience with testing, integrating testing into development workflows, and helping testers contribute to other parts of development to become true partners. The overall message is that testing is most effective when it is easy to do and an inherent part of the development process done collaboratively by the entire team.
Agileee 2012
The document discusses reversing the "tests pyramid" approach to address technical debt in legacy code. It notes that unit testing is difficult for code without separation of concerns, but refactoring without tests is risky. It proposes starting with high-level tests to gain confidence for refactoring into units and writing unit tests incrementally. However, end-to-end tests are long to maintain, and if needed, the architecture may be flawed. Reversing the tests pyramid and refactoring code in this way takes time but pays back technical debt and allows for sustainable changes. Beware of refactoring just for its own sake - focus on removing duplication and improving changeability.
Creating test stability to create continuous delivery
Trisha Chetani discusses her experience transforming automated tests at Visenze from being slow and flaky to stable to enable continuous delivery. She analyzed the root causes of flakiness, which included changing locators, flows, and application slowness. Through coding best practices, team responsibility, stable environments, skills development, product testability improvements, and continuous learning, she was able to reduce test execution time from 30 to 5 minutes and maintain a stable pipeline.
A Concise QA Process
This document summarizes a concise QA and testing process developed for a small startup. It includes protocols for building, testing, managing changes, and releasing software. The build protocol ensures testing receives builds and information about changes. The test cycle protocol defines different types of testing cycles. The change protocol establishes feature freezes and code freezes to control changes late in development. The release protocol details the release approval and packaging process.
Implementing Agile : Do's and Don'ts
The document discusses dos and don'ts for implementing agile practices. It provides examples of both ideal (Teams A and B) and non-ideal (Teams C, D, and E) ways that teams have implemented agile. Some key dos included allowing the entire team to communicate with clients, following test-driven development and continuous integration practices, and automating deployment. Don'ts included micro-managing teams, relying too heavily on documentation over working software, and forming specialized subgroups within teams. The document emphasizes learning from mistakes and experiences to continuously improve agile implementation.
Arguments in favor of a progressive software rewrite
Arguments in favor of a progressive software rewrite .
Blog post here : https://sylvainleroy.com/2018/06/18/to-rewrite-or-not-to-rewrite-a-software/
It's a presentation about why software should be preserved and .
Written and adapted for Byoskill.
Byoskill.com
Test Driven Development
Testing is not something that traditional PHP developers are being familiar with. This session introduces the needs and means for testing, and the test-driven development model to create rock-solid PHP applications.
Examples how to move towards Zero Defects
This document provides an overview of approaches to achieving zero defects in software development. It discusses how adopting a "zero defects" attitude can reduce defects by 50% overnight. It emphasizes defect prevention through proper root cause analysis and design reviews over testing. Iterative design, implementation, and review cycles are recommended to find and address issues early. The goal of quality assurance is to help developers produce fewer defects by focusing on prevention rather than finding defects after the fact. The ultimate goal is to deliver working software to customers with "no questions and no issues."
B. Durrett The Challenges of Continuous Deployment Social Developer Summit
The document discusses continuous deployment, where code is deployed to production within 20 minutes of being committed. The author details how IMVU, a social media company, successfully uses this approach, deploying code up to 50 times per day. Some benefits are regressions are easy to find and fix, and releases have zero overhead. Challenges include outages, new testing needs, and increased coordination as the engineering team grows. Overall, the author argues that continuous deployment scales well and is a key part of a good development process.
Put "fast" back in "fast feedback"
One of the cornerstones in Agile development is fast feedback. For engineering, "fast" means "instantly" or "in 5 minutes", not "tomorrow" or "this week". Your engineering practices should ensure that you can answer yes to most of the following questions:
- Do we get all test results in less than 5 minutes after a commit?
- Is our code coverage more than 75% for both front-end and back-end?
- Can we start exploratory testing in less than 15 minutes after a commit?
- Do all our tests pass more than 90% of our commits?
This talk will give you practical advice on how to get to "yes, we get fast feedback".
Keynote AST 2016
The document discusses various aspects of automating software testing. It suggests automating the detection of flaky tests, determining the severity of test failures, converting tests to more isolated unit tests, and using usage data to determine what to test next. It emphasizes that while automation can improve testing efficiency, human oversight is still needed, and code reviews serve as the link between automated and manual processes.
Test pyramid
The document discusses different types of software tests including unit tests, integration tests, service tests, and UI end-to-end tests. Unit tests check individual components, integration tests verify communication between components, service tests validate API requests and responses, and UI end-to-end tests simulate user interactions to check the full application. The document also provides an example of a student result service test response.
Why Automated Testing Matters To DevOps
“Automated testing is a pain in my ear! Why can’t QA get it right? Why do the tests keep breaking? And for Pete’s sake, stop blaming the infrastructure!”
…Ok, maybe you chose a different word than “ear”.
How often do you have thoughts like this? Daily?
Let’s talk about these frustrations, why they exist and how we can use them to improve our systems!
In this talk, Paul Merrill, founder and Principal Automation Engineer at Beaufort Fairmont explores why automated testing matters to DevOps. Join us to learn how automated testing can be a useful tool in the creation and release of your systems!
Optimizing Your Agile Testing Processes
An overview of agile testing and how to incorporate it into an agile software development process.
From a Webinar by uTest: http://www.utest.com/webinar_agile_testing.htm
Test driven development
This document discusses Test Driven Development (TDD). TDD helps create clean, simple code designs with low coupling between components. Writing tests first allows developing code with confidence as tests accumulate. It helps avoid technical debt by refactoring code as needed. TDD produces documentation in the form of executable tests and enables continuous integration and delivery. The TDD process follows the "Red-Green-Refactor" mantra of writing a failing test first, then code to pass the test, and refactoring code as needed. Tests should be written to be fast, independent, repeatable, self-validating, and timely. Tools and coding dojos can help practice and improve TDD skills.
Testing in java
Testing in Java discusses different types of software tests including unit tests, integration tests, and automation tests. It outlines the benefits of testing such as better code quality, fewer bugs, and more reliable software. Various Java testing tools and frameworks are also introduced like JUnit, Mockito, and PowerMock. Sample test code is demonstrated using annotations and assertions to validate expected outcomes.
Test Driven Development
Test Driven Development (TDD) provides several benefits over traditional waterfall and iterative development models:
1) It establishes a fast feedback cycle between writing code and writing tests, allowing developers to quickly validate functionality.
2) The automated tests that are written serve as documentation and specifications for the code, giving confidence that changes don't break existing functionality.
3) High test coverage promotes well-designed, loosely-coupled code that is easier to maintain and extend over time.
Automation testing in Agile project
The document summarizes best practices for test automation, including:
- Unit tests should be automated as the first step and follow naming conventions.
- Integration and performance tests require grouping, isolation, and handling test data issues.
- UI tests can be automated with Selenium and integrated into the build pipeline.
- Automated test data, code, and plan generation may be useful once a project's structure stabilizes.
- Automation aims to provide transparency, improve skills, and reduce manual work over time through a smarter approach.
What's hot (20)
Performance Metrics for your Delivery Pipeline - Wolfgang Gottesheim
Performance Metrics for your Delivery Pipeline - Wolfgang Gottesheim
Creating test stability to create continuous delivery
Creating test stability to create continuous delivery
Arguments in favor of a progressive software rewrite
Arguments in favor of a progressive software rewrite
B. Durrett The Challenges of Continuous Deployment Social Developer Summit
B. Durrett The Challenges of Continuous Deployment Social Developer Summit
Viewers also liked
Building Scalable .NET Apps
Guy Nirpaz is the EVP of R&D at GigaSpaces Technologies. He has experience with several startups in designing and architecting complex systems. GigaSpaces provides a scale-out platform optimized for distributed environments that can handle unpredictable demand through linear and dynamic scalability. Traditional tier-based architectures are not scalable as they rely on centralized resources. The presentation explores building scalable applications by addressing the limitations of fundamental architectures and proposing cost-effective alternatives like caching, partitioning, and dynamic scaling based on SLAs.
Performance Tuning of .NET Application
This document discusses performance tuning of .NET applications. It begins by defining performance tuning as improving system performance. It then discusses identifying bottlenecks through profiling, such as by using dotTrace and dotMemory tools. Various ways to optimize performance are covered, such as choosing appropriate collections, making applications parallel as needed, and managing memory efficiently by reducing allocation and using value types and IDisposable patterns. The document aims to provide guidance on optimizing .NET applications through measurement and profiling.
Improving Performance in .NET Applications
We all want to write fast code. But writing code that performs well doesn't come for free. Developers must be cognizant of what their code will do when it is executed, and what tools to use when you want to find the hot spots. In this session, we'll cover what a .NET developer needs to know to improve the performance of their applications.
.Net Performance by Bijoy Singhal
This document discusses .NET performance tips and techniques. It provides an overview of common .NET performance issues such as memory leaks, exceptions, and slow loading applications. It also introduces tools in the .NET framework that can help debug these issues, such as Fusion Log Viewer, Native Image Generator, and Performance Monitor counters. Specific scenarios are presented around resolving FileNotFoundExceptions, improving load time, identifying memory leaks, and troubleshooting PInvoke issues. The document emphasizes that performance is relative and introduces approaches like adding trace messages and using debugging tools to analyze problems.
Adam Sitnik "State of the .NET Performance"
MSK DOT NET #5
2016-12-07
In this talk Adam will describe how latest changes in.NET are affecting performance.
Adam wants to go through:
C# 7: ref locals and ref returns, ValueTuples.
.NET Core: Spans, Buffers, ValueTasks
And how all of these things help build zero-copy streams aka Channels/Pipelines which are going to be a game changer in the next year.
How to Do a Performance Audit of Your .NET Website
The hardest part about website performance optimization is identifying the root cause.
In this presentation, Bruce Chapman, Director of Cloud and Web Operations at DNN, shows you how to perform a comprehensive performance audit of your .NET website.
You’ll learn how to uncover the causes of performance issues, and understand that improving performance is often straightforward once the root cause is identified.
Building Scalable .NET Web Applications
1. The document discusses strategies for scaling web applications, including scaling the client, web/application, and database tiers.
2. It covers techniques like load balancing, domain sharding, caching, and database partitioning to distribute load across servers.
3. Scaling the database tier involves strategies such as replication, indexing, and moving to NoSQL databases which sacrifice some consistency for improved scalability.
10 performance and scalability secrets of ASP.NET websites
1) ASP.NET requires optimizations at the code, database, and configuration levels to scale to millions of hits out of the box. Common optimizations include tweaking process model settings, removing unnecessary pipeline components, and using compiled Linq queries.
2) Issues like application-level DOS attacks, slow profile provider stored procedures, and Linq to SQL performance problems can be addressed to improve scalability. Using a CDN can also help offload static content delivery.
3) Database queries must consider index usage and transaction isolation levels to prevent timeouts and deadlocks under high load.
Four Practices to Fix Your Top .NET Performance Problems
Inefficient Database Access, Inefficien Pool usage and Sizing, Bad Synchronization, Bad Web Page Design - these are the problems that crash .NET Apps. Learn how to analyze them and fix these problems
Metrics Driven DevOps - Automate Scalability and Performance Into your Pipeline
Continuous Delivery only works if you combine automation with automatic metrics driven quality gates focusing on architectural, scalabilty and performance metrics.
In this presentation I start with several dashboard examples explaining key metrics in production and explain how to automate these metrics into your delivery pipeline.
Viewers also liked (10)
How to Do a Performance Audit of Your .NET Website
How to Do a Performance Audit of Your .NET Website
10 performance and scalability secrets of ASP.NET websites
10 performance and scalability secrets of ASP.NET websites
Four Practices to Fix Your Top .NET Performance Problems
Four Practices to Fix Your Top .NET Performance Problems
Metrics Driven DevOps - Automate Scalability and Performance Into your Pipeline
Metrics Driven DevOps - Automate Scalability and Performance Into your Pipeline
Similar to PHX Session #3 - "It Works on My Machine!" Closing the Loop Between Development & Testing
Session #3: "It Works on My Machine!" Closing the Loop Between Development & ...
This document discusses closing the loop between development and testing. It addresses whose responsibility it is to find and fix bugs, and how teams should communicate about bug status. The document advocates that quality is a shared responsibility of both developers and testers. It also promotes automating testing where possible to reduce manual effort and ensure bugs found are reproducible.
Role of Retrospectives in Success of Agile Project
Bap's presentation on Role of Retrospectives in Success of Agile Project at the Agile 2006 conference in Bangalore
Guerilla Usability Testing
Usability testing involves having people complete tasks while thinking aloud to provide insight into their thought processes. It can be done using paper prototypes, websites, or existing sites. Benefits for designers include uncovering unexpected issues, testing assumptions, and getting stakeholder buy-in. Benefits for site owners are fixing problems early when cheaper, improving customer satisfaction, and increasing conversion rates. Guerilla or informal testing is quick, inexpensive, and provides qualitative insights that can immediately feed back into the design process. It involves recruiting your own test subjects and moderating the sessions yourself.
Just Java2007 - Daniel Wildt - Tools For Java Test Automation
The document discusses tools and techniques for Java test automation, including unit testing, functional testing, test-driven development, continuous integration, and ensuring test quality and coverage. It covers topics like white box and black box testing, mock objects, Selenium for functional tests, JMeter for stress testing, and Emma for code coverage. References and links to tools like JUnit, FitNesse, EasyMock, CheckStyle, and CruiseControl are also provided.
Continuous Integration for Citizens
The document discusses continuous integration and incremental development. It defines continuous integration as a pipeline with jobs that can run in parallel and produce artifacts that other jobs depend on. Incremental development involves requirement-driven development, integrity of changes not harming other parts of the system, ability to deploy changes, isolation of changes, and being ready for release at any time. The document provides examples of tools that can be used for continuous integration, such as Jenkins, Travis CI, and Bamboo. It also discusses risks of relying on CI infrastructure and people not writing tests.
Even More Agile
The document describes how an agile project team at ThoughtWorks refactored their process to address problems like long story card lifecycles, bugs, slow build times, and communication issues between distributed teams. They made changes such as having teams own story cards, using pairing and smaller co-located teams, emphasizing testing, creating visual boards, improving developer environments, and fostering more communication. These process changes have led to visible progress, higher customer trust, improved morale and productivity, and an overall more enjoyable work experience for the team.
The 7 Sins of Software Engineers in HEP
The document discusses 7 sins of software engineers in high energy physics (HEP) projects. It describes each sin with an observation, problem it causes, and proposed solution. The sins are: being too reliant on tools, writing code before designing, flawed processes, reinventing wheels, making software functional but not usable, documentation paralysis, and resistance to change. The document advocates automating work, designing before coding, minimal necessary processes, reusing code, prioritizing usability, automatically generating documentation, and adapting to change.
Better Perl Practices
This presentation was at the Japanese Perl Association Seminar #1 in Akihabara on April 21st, 2009.
It covers ideas for how to have establish good habits one by one, and strategies to get them to stick.
Agile Development Methodologies
The document discusses various agile development methodologies. It defines agile development as delegating tasks, acknowledging change, and promoting feedback. Several specific agile methodologies are described, including extreme programming, Scrum, lean software development, feature driven development, agile unified process, Crystal, dynamic systems development method, and cowboy coding. The document provides information on principles, practices, and comparisons of these different agile methodologies.
How the JDeveloper team test JDeveloper at UKOUG'08
The document discusses how the Oracle JDeveloper team tests JDeveloper. It covers their use of automation, tools like Abbot and Selenium for testing. Some key points include that they do not have 100% test coverage but focus on testing critical areas. They discuss what to automate like builds and common workflows. Abbot is used for testing Swing components while Selenium is used for browser-based testing. Screenshots and logs are captured when tests fail to aid in debugging.
Continuous Integration for Citizens
The document discusses continuous integration and incremental development. It defines continuous integration as a pipeline with jobs that can run in parallel and produce artifacts that other jobs depend on. Incremental development involves implementing features in a way that maintains the integrity of the existing system and enables easy deployment. It is driven by requirements and tests, uses source control management, and aims for the system to be releasable at any time. Continuous integration helps achieve many of the goals of incremental development through automated testing, monitoring, and deployment pipelines.
PHX Session #1: Development Best Practices And How Microsoft Helps
The document discusses how Microsoft's Visual Studio Team System (VSTS) helps development teams improve their application lifecycle management practices. It describes VSTS tools that enable teams to collaborate and communicate, manage workflows, drive predictability through process templates, ensure quality through testing tools integrated at all stages of development, integrate work frequently through version control and builds, and make real-time decisions using reporting. VSTS provides an end-to-end solution to support all roles from requirements to deployment.
Unit testing traning
The document discusses the importance of unit testing at different levels. It emphasizes that tests allow for safe refactoring, are a safety requirement, and help speed up development. Developer tests are important for faster development and validation. Mocked contract tests help ensure code changes don't break consumers. Stress and chaos tests are also important to test how systems handle load, failures, and edge cases. The document encourages testing beyond happy paths by considering invalid data, exceptions, and other scenarios. It concludes by noting the importance of coverage goals to help developers learn to write stable code.
Usability
Usability testing involves evaluating a product's ease of use and user satisfaction. It is important for ensuring users can achieve their goals effectively and efficiently. There are different methods for testing such as formative usability tests conducted early in the design process and summative tests conducted on later prototypes. Tests are planned, data is collected either through participant observation or surveys, then analyzed to help iterate and improve the design.
Usability Engineering
This document discusses usability engineering and provides an overview of key concepts in the field. It defines usability and discusses the usability engineering lifecycle, which includes understanding users, prototyping, testing interfaces, and iterative design. Methods like heuristic evaluation, usability testing, and internationalization considerations are also covered. The document concludes by discussing potential future developments in usability like increased natural language and adaptive interfaces.
The Most Important Thing: How Mozilla Does Security and What You Can Steal
The document discusses Mozilla's approach to software security and provides recommendations for how to implement an effective security process. Some of the key points covered include:
1) Security is not a linear process and should have feedback loops to continuously learn from problems and prevent recurrences.
2) The most important thing is to systematically capture knowledge from security incidents to avoid repeating mistakes.
3) Extensive testing is critical to maintain security and catch issues early, with Mozilla running over 55,000 automated tests daily.
4) Code reviews should be mandatory to catch mistakes and spread security knowledge throughout the organization.
Gw Pres Agile 4slideshare
Background and lessons learned from adoption of agile design and development methodologies in a web project at Washington Post Media. Delivered at George Washington University, Oct. 2008
Just In Time Scalability Agile Methods To Support Massive Growth Presentation
IMVU is an online destination where adults and teens meet new people in 3D. IMVU won the 2008 Virtual Worlds Innovation Award and was also named a Rising Star in the 2008 Silicon Valley Technology Fast 50 program.
These are excerpts from the IMVU PDF presentation of their architecture which can be viewed or downloaded here.
Bug Advocacy
1. The document discusses the concept of "bug advocacy", which is the practice of writing bug reports in a way that motivates programmers to fix the bug.
2. Effective bug reports motivate programmers by highlighting how serious or widespread the bug is. They also overcome objections by providing clear reproduction steps and evidence of customer impact.
3. The document recommends testing around found bugs to prove they are more serious or common than initially thought. This includes varying your own actions, program settings, and software/hardware environment to trigger related or worse failures. The goal is to sell programmers on the importance of fixing the bug.
Hardening
This document discusses various types of software testing and their purposes. It covers unit testing, snapshot testing, property-based testing, contract testing, mutation testing, stress/load testing, chaos testing, and testing for different environments including backend, frontend, and cloud-native applications. The key points made are that different types of testing are needed to have confidence a solution works, catch regressions, avoid breaking consumers, ensure survivability of failures, and build the right product. Testing approaches must evolve with architectural changes like moving to the cloud. Isolation is important for hardening production systems.
Similar to PHX Session #3 - "It Works on My Machine!" Closing the Loop Between Development & Testing (20)
Session #3: "It Works on My Machine!" Closing the Loop Between Development & ...
Session #3: "It Works on My Machine!" Closing the Loop Between Development & ...
Role of Retrospectives in Success of Agile Project
Role of Retrospectives in Success of Agile Project
Just Java2007 - Daniel Wildt - Tools For Java Test Automation
Just Java2007 - Daniel Wildt - Tools For Java Test Automation
How the JDeveloper team test JDeveloper at UKOUG'08
How the JDeveloper team test JDeveloper at UKOUG'08
PHX Session #1: Development Best Practices And How Microsoft Helps
PHX Session #1: Development Best Practices And How Microsoft Helps
The Most Important Thing: How Mozilla Does Security and What You Can Steal
The Most Important Thing: How Mozilla Does Security and What You Can Steal
Just In Time Scalability Agile Methods To Support Massive Growth Presentation
Just In Time Scalability Agile Methods To Support Massive Growth Presentation
More from Steve Lange
Visual Studio ALM 2013 - Edition Comparison
This document compares editions of Microsoft's Visual Studio 2013 integrated development environment (IDE). It provides a detailed comparison of the key capabilities included in the Ultimate, Premium, Test Pro, Professional, and MSDN editions. The comparison covers capabilities for application development, testing, architecture/modeling, team collaboration, and cloud/mobile development support. It also includes the monthly Windows Azure credit and platforms supported by the MSDN subscription for each edition.
Team Foundation Server 2012 Reporting
An overview of the reporting capabilities in Team Foundation Server 2012. Includes explanation of Data warehouse architecture, included reports (SSRS and Excel), and customization.
A Deeper Look at Team Foundation Server 2012 Version Control
The document discusses version control in Team Foundation Server 2012, including features like server and local workspaces, checking in and out files with different lock types, labeling versions, getting and adding files from version control, and integrating version control with the ALM capabilities in Visual Studio and TFS. It also briefly mentions converting version control repositories from other systems like Visual SourceSafe and ClearCase into TFS.
Upgrading to TFS 2010
This document discusses upgrading Team Foundation Server. It describes the different types of upgrades including in-place, migration-based, and consolidation upgrades. It provides details on the upgrade process such as verifying system requirements, backing up data, upgrading SQL Server, and installing the new version of TFS. It also covers considerations for the upgrade like how process templates, reports, and the data warehouse are handled as well as recommendations to backup and test the restore before performing the upgrade.
Microsoft ALM Platform Overview
Microsoft Application Lifecycle Management (ALM) integrates governance, development, and operations from idea to retirement. Microsoft's ALM platform focuses on implementing process with minimal overhead, planning and managing projects, and aligning roles across the lifecycle. It allows reporting across project boundaries. The platform provides process templates, tools for planning and visibility, and ensures user comfort by allowing work in familiar tools. It aims to create happy teams and enable success throughout the application lifecycle.
Team Foundation Server - Tracking & Reporting
Comprehensive presentation detailing reporting and tracking capabilities of Team Foundation Server. Focuses on Excel workbooks and Reporting Services, but touches on other technologies as well.
Visual Studio 2010 Testing for Developers
The document discusses testing tools in Visual Studio 2010 that help developers get code right the first time. It describes features like code analysis, code metrics, test impact analysis, IntelliTrace for debugging, and performance profiling. The tools help improve code quality, find bugs more quickly, and reduce "no repro" issues. The presentation includes demos of these tools and how they can help foster better collaboration between developers and testers.
Visual Studio LightSwitch (Beta 1) Overview
Visual Studio LightSwitch allows developers to quickly create professional, data-centric business applications. It provides pre-configured screen templates and pre-written code to build the basic application functionality faster. LightSwitch applications can access existing data sources like SQL Server and SharePoint. The applications are made up of projects containing data entities, screens, queries, and other resources. Developers can customize and extend LightSwitch applications through code. LightSwitch applications can be deployed to the desktop, browser, or cloud.
Team Foundation Server 2010 - Overview
A full overview of Team Foundation Server 2010 (not just what's new).
Includes 4 main areas:
- Manage & Plan your Project
- Understand Parallel Development
- No More "No Repro" Bugs
- Reporting on your Entire Portfolio.
Screenshots are included.
Visual Studio 2010 Testing Overview
This document discusses testing capabilities in Visual Studio 2010, including test case management, lab management, exploratory testing, and coded UI testing. It highlights how Visual Studio 2010 aims to align testing with the development lifecycle and enable tighter collaboration between developers and testers. Key capabilities like test case management allow tracking test cases as work items in Team Foundation Server, while lab management helps simplify environment setup and improves test hardware utilization.
TFS 2010: Team Development on Crack
Steve Lange's afternoon session at the Rocky Mountain Tech Tri-Fecta (http://rmtechtrifecta.com) on 2/27/2010.
Team Foundation Server 2010 - Version Control
The document summarizes Team Foundation Server 2010's version control capabilities. It discusses key concepts like changesets, integrated check-ins, check-in policies, workspaces, and shelving. It also covers labeling, comparing/diffing, branching and merging code, and how version control integrates with other TFS components like build and work item tracking. The presentation aims to explain the architecture and capabilities of TFS version control.
Whats New In 2010 (Msdn & Visual Studio)
This document provides an overview and summary of new features in Visual Studio 2010 and Team Foundation Server 2010. It begins with introducing the product lineup and changes to MSDN subscriptions. Major sections then summarize new capabilities in project management, reporting, version control, architecture/modeling tools, development aids like profiling and testing tools like lab management and coded UI tests. The document aims to outline the key updates and highlights for developers across the application lifecycle with Visual Studio 2010 and TFS.
PHX Session #5 : Architecture Without Big Design Up Front (Garibay)
This document discusses software architecture and how it relates to agile development. It defines architecture as the fundamental organization of a system, including its components and relationships. The document advocates discovering an existing system's architecture to understand it before making changes. It presents the 4+1 architectural views model and shows how Visual Studio 2010 supports modeling with tools like Architecture Explorer and layer diagrams.
PHX Session #6: More Bang for Your Buck: Getting the Most out of Team Foundat...
This document summarizes a presentation about getting the most value from Microsoft's Team Foundation Server (TFS). The presentation covers how TFS can be used for more than just .NET development, including using it for version control of any file type and size. It demonstrates using TFS for work item tracking, linking related items, and using Excel for reporting. The presentation also discusses using TFS for build automation and testing, and leveraging the new "fire and forget" user licensing. It concludes by discussing upcoming improvements to TFS like hierarchical work items and improved branching capabilities.
PHX - Session #4 Treating Databases as First-Class Citizens in Development
The document discusses treating databases as first-class citizens in development by managing schemas and data through database projects and tools. It addresses questions around where the truth of a schema resides, how to version databases, generate test data, perform unit testing, and manage changes. The key points are using database projects to represent the truth of the schema, version control to manage versions, test data generators for testing, and schema/data comparison tools to facilitate refactoring and managing changes.
Big Event Looping Deck
The document outlines an agenda for a Team System Big Event hosted by Microsoft. The all day event includes sessions on development best practices, test driven development, closing the loop between development and testing, treating databases as first-class citizens, architecture without big design up front, and getting the most out of Team Foundation Server. Speakers are from Microsoft and partner organizations and will discuss topics related to application development, testing, and use of the Microsoft development tools and platforms.
Session #6: Get More Bang For Your Buck
This document discusses how to get more value from using Team Foundation Server (TFS) by utilizing its various features beyond only source code version control and basic work item tracking. It highlights TFS capabilities for version control like file annotation and change tracking across branches. It also discusses using TFS for build automation, reporting with Excel, and upcoming improvements to features like hierarchical work items and improved branching capabilities. The document encourages fully leveraging TFS capabilities and getting more people involved with access through new licensing changes.
Session #1: Development Practices And The Microsoft Approach
This document discusses Microsoft's approach to development best practices, which focuses on collaboration, managing team workflow, driving predictability, ensuring quality early and often, and integrating work frequently. It describes how Microsoft's Visual Studio Team System provides tools to help with collaboration, work tracking, process guidance, testing, version control, and reporting to support development teams.
Session #4: Treating Databases as First-Class Citizens in Development
The document discusses treating databases as first-class citizens in development by managing schemas and data through database projects and tools. It addresses questions around where the truth of a schema resides, how to version databases, generate test data, perform unit testing, and manage changes. The key points are using database projects to represent the truth of the schema, version control to manage versions, test data generators for testing, and tools for schema/data compares and refactoring to facilitate change management.
More from Steve Lange (20)
A Deeper Look at Team Foundation Server 2012 Version Control
A Deeper Look at Team Foundation Server 2012 Version Control
PHX Session #5 : Architecture Without Big Design Up Front (Garibay)
PHX Session #5 : Architecture Without Big Design Up Front (Garibay)
PHX Session #6: More Bang for Your Buck: Getting the Most out of Team Foundat...
PHX Session #6: More Bang for Your Buck: Getting the Most out of Team Foundat...
PHX - Session #4 Treating Databases as First-Class Citizens in Development
PHX - Session #4 Treating Databases as First-Class Citizens in Development
Session #1: Development Practices And The Microsoft Approach
Session #1: Development Practices And The Microsoft Approach
Session #4: Treating Databases as First-Class Citizens in Development
Session #4: Treating Databases as First-Class Citizens in Development
Recently uploaded
AppSec PNW: Android and iOS Application Security with MobSF
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor Ivaniuk
At this talk we will discuss DDoS protection tools and best practices, discuss network architectures and what AWS has to offer. Also, we will look into one of the largest DDoS attacks on Ukrainian infrastructure that happened in February 2022. We'll see, what techniques helped to keep the web resources available for Ukrainians and how AWS improved DDoS protection for all customers based on Ukraine experience
Essentials of Automations: Exploring Attributes & Automation Parameters
Building automations in FME Flow can save time, money, and help businesses scale by eliminating data silos and providing data to stakeholders in real-time. One essential component to orchestrating complex automations is the use of attributes & automation parameters (both formerly known as “keys”). In fact, it’s unlikely you’ll ever build an Automation without using these components, but what exactly are they?
Attributes & automation parameters enable the automation author to pass data values from one automation component to the next. During this webinar, our FME Flow Specialists will cover leveraging the three types of these output attributes & parameters in FME Flow: Event, Custom, and Automation. As a bonus, they’ll also be making use of the Split-Merge Block functionality.
You’ll leave this webinar with a better understanding of how to maximize the potential of automations by making use of attributes & automation parameters, with the ultimate goal of setting your enterprise integration workflows up on autopilot.
Fueling AI with Great Data with Airbyte Webinar
This talk will focus on how to collect data from a variety of sources, leveraging this data for RAG and other GenAI use cases, and finally charting your course to productionalization.
Programming Foundation Models with DSPy - Meetup Slides
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
"Choosing proper type of scaling", Olena Syrota
Imagine an IoT processing system that is already quite mature and production-ready and for which client coverage is growing and scaling and performance aspects are life and death questions. The system has Redis, MongoDB, and stream processing based on ksqldb. In this talk, firstly, we will analyze scaling approaches and then select the proper ones for our system.
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
Northern Engraving | Nameplate Manufacturing Process - 2024
Manufacturing custom quality metal nameplates and badges involves several standard operations. Processes include sheet prep, lithography, screening, coating, punch press and inspection. All decoration is completed in the flat sheet with adhesive and tooling operations following. The possibilities for creating unique durable nameplates are endless. How will you create your brand identity? We can help!
JavaLand 2024: Application Development Green Masterplan
My presentation slides I used at JavaLand 2024
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAU
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-und-domino-lizenzkostenreduzierung-in-der-welt-von-dlau/
DLAU und die Lizenzen nach dem CCB- und CCX-Modell sind für viele in der HCL-Community seit letztem Jahr ein heißes Thema. Als Notes- oder Domino-Kunde haben Sie vielleicht mit unerwartet hohen Benutzerzahlen und Lizenzgebühren zu kämpfen. Sie fragen sich vielleicht, wie diese neue Art der Lizenzierung funktioniert und welchen Nutzen sie Ihnen bringt. Vor allem wollen Sie sicherlich Ihr Budget einhalten und Kosten sparen, wo immer möglich. Das verstehen wir und wir möchten Ihnen dabei helfen!
Wir erklären Ihnen, wie Sie häufige Konfigurationsprobleme lösen können, die dazu führen können, dass mehr Benutzer gezählt werden als nötig, und wie Sie überflüssige oder ungenutzte Konten identifizieren und entfernen können, um Geld zu sparen. Es gibt auch einige Ansätze, die zu unnötigen Ausgaben führen können, z. B. wenn ein Personendokument anstelle eines Mail-Ins für geteilte Mailboxen verwendet wird. Wir zeigen Ihnen solche Fälle und deren Lösungen. Und natürlich erklären wir Ihnen das neue Lizenzmodell.
Nehmen Sie an diesem Webinar teil, bei dem HCL-Ambassador Marc Thomas und Gastredner Franz Walder Ihnen diese neue Welt näherbringen. Es vermittelt Ihnen die Tools und das Know-how, um den Überblick zu bewahren. Sie werden in der Lage sein, Ihre Kosten durch eine optimierte Domino-Konfiguration zu reduzieren und auch in Zukunft gering zu halten.
Diese Themen werden behandelt
- Reduzierung der Lizenzkosten durch Auffinden und Beheben von Fehlkonfigurationen und überflüssigen Konten
- Wie funktionieren CCB- und CCX-Lizenzen wirklich?
- Verstehen des DLAU-Tools und wie man es am besten nutzt
- Tipps für häufige Problembereiche, wie z. B. Team-Postfächer, Funktions-/Testbenutzer usw.
- Praxisbeispiele und Best Practices zum sofortigen Umsetzen
Choosing The Best AWS Service For Your Website + API.pptx
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
Crafting Excellence: A Comprehensive Guide to iOS Mobile App Development Serv...
Crafting Excellence: A Comprehensive Guide to iOS Mobile App Development Serv...Pitangent Analytics & Technology Solutions Pvt. Ltd
Discover top-tier mobile app development services, offering innovative solutions for iOS and Android. Enhance your business with custom, user-friendly mobile applications.Biomedical Knowledge Graphs for Data Scientists and Bioinformaticians
Dmitrii Kamaev, PhD
Senior Product Owner - QIAGEN
“Temporal Event Neural Networks: A More Efficient Alternative to the Transfor...
“Temporal Event Neural Networks: A More Efficient Alternative to the Transfor...Edge AI and Vision Alliance
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/temporal-event-neural-networks-a-more-efficient-alternative-to-the-transformer-a-presentation-from-brainchip/
Chris Jones, Director of Product Management at BrainChip , presents the “Temporal Event Neural Networks: A More Efficient Alternative to the Transformer” tutorial at the May 2024 Embedded Vision Summit.
The expansion of AI services necessitates enhanced computational capabilities on edge devices. Temporal Event Neural Networks (TENNs), developed by BrainChip, represent a novel and highly efficient state-space network. TENNs demonstrate exceptional proficiency in handling multi-dimensional streaming data, facilitating advancements in object detection, action recognition, speech enhancement and language model/sequence generation. Through the utilization of polynomial-based continuous convolutions, TENNs streamline models, expedite training processes and significantly diminish memory requirements, achieving notable reductions of up to 50x in parameters and 5,000x in energy consumption compared to prevailing methodologies like transformers.
Integration with BrainChip’s Akida neuromorphic hardware IP further enhances TENNs’ capabilities, enabling the realization of highly capable, portable and passively cooled edge devices. This presentation delves into the technical innovations underlying TENNs, presents real-world benchmarks, and elucidates how this cutting-edge approach is positioned to revolutionize edge AI across diverse applications.Dandelion Hashtable: beyond billion requests per second on a commodity server
This slide deck presents DLHT, a concurrent in-memory hashtable. Despite efforts to optimize hashtables, that go as far as sacrificing core functionality, state-of-the-art designs still incur multiple memory accesses per request and block request processing in three cases. First, most hashtables block while waiting for data to be retrieved from memory. Second, open-addressing designs, which represent the current state-of-the-art, either cannot free index slots on deletes or must block all requests to do so. Third, index resizes block every request until all objects are copied to the new index. Defying folklore wisdom, DLHT forgoes open-addressing and adopts a fully-featured and memory-aware closed-addressing design based on bounded cache-line-chaining. This design offers lock-free index operations and deletes that free slots instantly, (2) completes most requests with a single memory access, (3) utilizes software prefetching to hide memory latencies, and (4) employs a novel non-blocking and parallel resizing. In a commodity server and a memory-resident workload, DLHT surpasses 1.6B requests per second and provides 3.5x (12x) the throughput of the state-of-the-art closed-addressing (open-addressing) resizable hashtable on Gets (Deletes).
5th LF Energy Power Grid Model Meet-up Slides
5th Power Grid Model Meet-up
It is with great pleasure that we extend to you an invitation to the 5th Power Grid Model Meet-up, scheduled for 6th June 2024. This event will adopt a hybrid format, allowing participants to join us either through an online Mircosoft Teams session or in person at TU/e located at Den Dolech 2, Eindhoven, Netherlands. The meet-up will be hosted by Eindhoven University of Technology (TU/e), a research university specializing in engineering science & technology.
Power Grid Model
The global energy transition is placing new and unprecedented demands on Distribution System Operators (DSOs). Alongside upgrades to grid capacity, processes such as digitization, capacity optimization, and congestion management are becoming vital for delivering reliable services.
Power Grid Model is an open source project from Linux Foundation Energy and provides a calculation engine that is increasingly essential for DSOs. It offers a standards-based foundation enabling real-time power systems analysis, simulations of electrical power grids, and sophisticated what-if analysis. In addition, it enables in-depth studies and analysis of the electrical power grid’s behavior and performance. This comprehensive model incorporates essential factors such as power generation capacity, electrical losses, voltage levels, power flows, and system stability.
Power Grid Model is currently being applied in a wide variety of use cases, including grid planning, expansion, reliability, and congestion studies. It can also help in analyzing the impact of renewable energy integration, assessing the effects of disturbances or faults, and developing strategies for grid control and optimization.
What to expect
For the upcoming meetup we are organizing, we have an exciting lineup of activities planned:
-Insightful presentations covering two practical applications of the Power Grid Model.
-An update on the latest advancements in Power Grid -Model technology during the first and second quarters of 2024.
-An interactive brainstorming session to discuss and propose new feature requests.
-An opportunity to connect with fellow Power Grid Model enthusiasts and users.
HCL Notes and Domino License Cost Reduction in the World of DLAU
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
Apps Break Data
How information systems are built or acquired puts information, which is what they should be about, in a secondary place. Our language adapted accordingly, and we no longer talk about information systems but applications. Applications evolved in a way to break data into diverse fragments, tightly coupled with applications and expensive to integrate. The result is technical debt, which is re-paid by taking even bigger "loans", resulting in an ever-increasing technical debt. Software engineering and procurement practices work in sync with market forces to maintain this trend. This talk demonstrates how natural this situation is. The question is: can something be done to reverse the trend?
Columbus Data & Analytics Wednesdays - June 2024
Columbus Data & Analytics Wednesdays, June 2024 with Maria Copot 20
Recently uploaded (20)
AppSec PNW: Android and iOS Application Security with MobSF
AppSec PNW: Android and iOS Application Security with MobSF
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor Ivaniuk
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor Ivaniuk
Essentials of Automations: Exploring Attributes & Automation Parameters
Essentials of Automations: Exploring Attributes & Automation Parameters
Programming Foundation Models with DSPy - Meetup Slides
Programming Foundation Models with DSPy - Meetup Slides
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...
Northern Engraving | Nameplate Manufacturing Process - 2024
Northern Engraving | Nameplate Manufacturing Process - 2024
JavaLand 2024: Application Development Green Masterplan
JavaLand 2024: Application Development Green Masterplan
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAU
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAU
Choosing The Best AWS Service For Your Website + API.pptx
Choosing The Best AWS Service For Your Website + API.pptx
Crafting Excellence: A Comprehensive Guide to iOS Mobile App Development Serv...
Crafting Excellence: A Comprehensive Guide to iOS Mobile App Development Serv...
Biomedical Knowledge Graphs for Data Scientists and Bioinformaticians
Biomedical Knowledge Graphs for Data Scientists and Bioinformaticians
“Temporal Event Neural Networks: A More Efficient Alternative to the Transfor...
“Temporal Event Neural Networks: A More Efficient Alternative to the Transfor...
Dandelion Hashtable: beyond billion requests per second on a commodity server
Dandelion Hashtable: beyond billion requests per second on a commodity server
HCL Notes and Domino License Cost Reduction in the World of DLAU
HCL Notes and Domino License Cost Reduction in the World of DLAU
Deep Dive: AI-Powered Marketing to Get More Leads and Customers with HyperGro...
Deep Dive: AI-Powered Marketing to Get More Leads and Customers with HyperGro...
PHX Session #3 - "It Works on My Machine!" Closing the Loop Between Development & Testing
- 1. “It works on my machine” Closing the loop between Development and Testing Dave McKinstry Principal Consultant – Notion Solutions, Inc dmckinstry@notionsolutions.com
- 2. Agenda Overview • Whose Bug is it anyway? • Yours, Mine and Ours • The bug stops here • Bug to the Future • Summary • Q&A •
- 3. Why Test? Why Not? •Why are we testing? •What are we testing? •Who is responsible for testing? •Do you want it on time or do you want it to be perfect? •How do you define a good test? •Bugs are bound to happen, why can’t we just live with it?
- 4. Whose bug is it anyway? • Picking teams – Beyond Development vs. Test • Finding bugs – Developer, tester or customer? • Communicating the status – We know about it, now what? • It’s fixed, what next? – Likely to resurface?
- 5. Picking Teams • producer • Development generates • non-mgmt • business • technical • customer • test • Management consumes • Business • Technical
- 6. Finding Bugs • Developers, testers or customers? • Is it important? • Understanding values
- 8. What’s Next? •Where do we go from here? •We’ve identified : •our teams, •our bug spotters •how they will be fixed •Will we have to repeat this during the next iteration? •Yes, if we don’t document and learn from this cycle. •No, if we do apply these lessons to our process.
- 9. DEMO Work Items for All
- 10. Yours, Mine and Ours Lines of code written Test Results gathered • • Number of bugs closed Number of bugs opened • • Shipping on time Shipping quality • • On to the next project Clearing the backlog • • So, what’s the common ground?
- 11. DEMO The Bug’s Life
- 12. The bug stops here Communicating Results • Are your statistics realistic? • Reinventing the wheel • Recognition •
- 13. DEMO We’re in this together, making sense of results
- 18. • 2010… Bug to the Future •Hierarchal work items •Eliminating “no-repro” bugs •Test impact analysis •Test prioritization •Viewing the quality of requirements and the value of testing •Reduce the manual effort for automation-capable tests
- 19. In summary • The most important tool is communication between dev and test. • Quality belongs to everyone, as does lack of. • Automation is a good friend to have. • Respect for your work, your colleagues, your customers.
- 20. Some Resources • http://msdn.microsoft.com – Documentation, references and samples • http://www.teamsystemrocks.com – Training Videos, Team System News and other Blogs • http://www.codeplex.com • http://www.notionsolutions.com • http://weblogs.asp.net/dmckinstry • http://www.tsug-ve.com • dmckinstry@notionsolutions.com
- 21. Q&A