Given at DogFoodCon 2016 in Columbus, Ohio
As developers, most of our time is spent working on existing software – even if it’s just the software we wrote ourselves, yesterday. And over time, software rots. If were not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car “ its preventive maintenance. In this session, Steve will cover some common places to look for signs of degradation in existing applications, and describe the steps we can take to improve our code. Examples will use C# and primarily ASP.NET.
Improving the Quality of Existing SoftwareSteven Smith
How do you improve the quality of your existing software, while continuing to add value for your customers? What are some heuristics and code smells you can look for, and principles and patterns you can use to guide you, as you make your software better over time instead of worse?
Breaking Dependencies to Allow Unit Testing - DevIntersection Spring 2016Steven Smith
Unit testing software can be difficult, especially when the software wasn't designed to be testable. Dependencies on infrastructure concerns and software we don't control are one of the biggest contributors to testing difficulty. In this session, you'll learn the difference between unit tests and other kinds of tests, how to recognize and invert dependencies, and how to unit test your code's interactions with these dependencies without testing the infrastructure itself.
Improving the Quality of Existing SoftwareSteven Smith
The document discusses techniques for improving the quality of existing software, including reducing technical debt, following principles like DRY and SOLID, using characterization tests to preserve behavior during refactoring, and improving skills to write higher quality code faster. It covers topics like refactoring, test-driven development, dependency inversion, and design patterns. The goal is to maintain and enhance application code quality over time through refactoring and preventing technical debt.
Improving The Quality of Existing SoftwareSteven Smith
Presented at DevReach 2013.
As developers, most of our time is spent working on existing software. Sure, occasionally we get the chance to fire up a new Solution in Visual Studio, and that can be exciting. But after the first day, we find ourselves once more having to deal with the work we did yesterday. And today, we know more than we did yesterday, so there are things we’d do differently, if we had it to do over.
Over time, software rots. If we’re not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car – it’s preventive maintenance. In this session, Steve will look at some common places to look for signs of degradation in existing applications, and steps to take to improve the code. Examples will use C# and primarily ASP.NET.
Improving the Quality of Existing Software - DevIntersection April 2016Steven Smith
How do you improve the quality of your existing software, while continuing to add value for your customers? What are some heuristics and code smells you can look for, and principles and patterns you can use to guide you, as you make your software better over time instead of worse? How can we improve our skills and techniques so that writing high quality software becomes our default, fastest way of working?
Breaking Dependencies to Allow Unit TestingSteven Smith
Unit testing software can be difficult, especially when the software wasn't designed to be testable. Dependencies on infrastructure concerns and software we don't control are one of the biggest contributors to testing difficulty. In this session, you'll learn the difference between unit tests and other kinds of tests, how to recognize and invert dependencies, and how to unit test your code's interactions with these dependencies without testing the infrastructure itself.
Breaking Dependencies to Allow Unit TestingSteven Smith
Unit testing software can be difficult, especially when the software wasn't designed to be testable. Dependencies on infrastructure concerns and software we don't control are one of the biggest contributors to testing difficulty. In this session, you'll learn the difference between unit tests and other kinds of tests, how to recognize and invert dependencies, and how to unit test your code's interactions with these dependencies without testing the infrastructure itself.
Presented at FalafelCON 2014, San Francisco, September 2014
The document discusses automated acceptance testing (AAT) in .NET. It provides an overview of AAT, including the benefits of communication, catching mistakes, and automation. It then discusses various AAT tools and frameworks for .NET, with a focus on SpecFlow for writing tests in Gherkin. The document demonstrates SpecFlow's workflow and syntax. It concludes by addressing challenges with AAT and providing tips for overcoming issues like brittle tests through techniques like page objects and headless browsers.
Improving the Quality of Existing SoftwareSteven Smith
How do you improve the quality of your existing software, while continuing to add value for your customers? What are some heuristics and code smells you can look for, and principles and patterns you can use to guide you, as you make your software better over time instead of worse?
Breaking Dependencies to Allow Unit Testing - DevIntersection Spring 2016Steven Smith
Unit testing software can be difficult, especially when the software wasn't designed to be testable. Dependencies on infrastructure concerns and software we don't control are one of the biggest contributors to testing difficulty. In this session, you'll learn the difference between unit tests and other kinds of tests, how to recognize and invert dependencies, and how to unit test your code's interactions with these dependencies without testing the infrastructure itself.
Improving the Quality of Existing SoftwareSteven Smith
The document discusses techniques for improving the quality of existing software, including reducing technical debt, following principles like DRY and SOLID, using characterization tests to preserve behavior during refactoring, and improving skills to write higher quality code faster. It covers topics like refactoring, test-driven development, dependency inversion, and design patterns. The goal is to maintain and enhance application code quality over time through refactoring and preventing technical debt.
Improving The Quality of Existing SoftwareSteven Smith
Presented at DevReach 2013.
As developers, most of our time is spent working on existing software. Sure, occasionally we get the chance to fire up a new Solution in Visual Studio, and that can be exciting. But after the first day, we find ourselves once more having to deal with the work we did yesterday. And today, we know more than we did yesterday, so there are things we’d do differently, if we had it to do over.
Over time, software rots. If we’re not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car – it’s preventive maintenance. In this session, Steve will look at some common places to look for signs of degradation in existing applications, and steps to take to improve the code. Examples will use C# and primarily ASP.NET.
Improving the Quality of Existing Software - DevIntersection April 2016Steven Smith
How do you improve the quality of your existing software, while continuing to add value for your customers? What are some heuristics and code smells you can look for, and principles and patterns you can use to guide you, as you make your software better over time instead of worse? How can we improve our skills and techniques so that writing high quality software becomes our default, fastest way of working?
Breaking Dependencies to Allow Unit TestingSteven Smith
Unit testing software can be difficult, especially when the software wasn't designed to be testable. Dependencies on infrastructure concerns and software we don't control are one of the biggest contributors to testing difficulty. In this session, you'll learn the difference between unit tests and other kinds of tests, how to recognize and invert dependencies, and how to unit test your code's interactions with these dependencies without testing the infrastructure itself.
Breaking Dependencies to Allow Unit TestingSteven Smith
Unit testing software can be difficult, especially when the software wasn't designed to be testable. Dependencies on infrastructure concerns and software we don't control are one of the biggest contributors to testing difficulty. In this session, you'll learn the difference between unit tests and other kinds of tests, how to recognize and invert dependencies, and how to unit test your code's interactions with these dependencies without testing the infrastructure itself.
Presented at FalafelCON 2014, San Francisco, September 2014
The document discusses automated acceptance testing (AAT) in .NET. It provides an overview of AAT, including the benefits of communication, catching mistakes, and automation. It then discusses various AAT tools and frameworks for .NET, with a focus on SpecFlow for writing tests in Gherkin. The document demonstrates SpecFlow's workflow and syntax. It concludes by addressing challenges with AAT and providing tips for overcoming issues like brittle tests through techniques like page objects and headless browsers.
The document discusses Selenium and Specflow, which are tools for automating browser testing and behavior-driven development. Selenium allows automating browsers through its WebDriver API, while Specflow uses Gherkin syntax like Given, When, Then to describe test cases in plain language. The document provides code examples and tips for thinking in behaviors rather than actions when using these tools, and recommends additional tools like NUnit and page object modeling to create robust and maintainable test automation.
Working Effectively with Legacy Code was presented at the 2012 DC Agile Engineering Conference on 12/7/2012 by Excella Managing Consultant Roberto Hernandez-Pou (@hernandezrobert).
Power-Up Your Test Suite with OLE Automation by Joshua RussellQA or the Highway
- Power-Up Your Test Suite With OLE Automation discusses using OLE Automation and the combination of Ruby and WIN32OLE for test automation of native Windows applications like Excel, Internet Explorer, and mainframe terminal emulators.
- OLE Automation allows automation of tasks on Windows applications through Microsoft's Automation interface when other popular options are unavailable. It provides access to an application's functionality through objects, properties, methods.
- Specific examples are provided for automating Excel workbooks and worksheets, controlling a mainframe terminal emulator, and integrating the automation into Cucumber scenarios. The presentation aims to demonstrate how OLE Automation can help "power up" a test suite.
The document discusses different layers of automated acceptance testing and compares different toolsets for each layer. The three layers are: 1) Acceptance Criteria Layer which defines test scenarios in a business-readable format, 2) Test Implementation Layer which implements tests against the system under test, and 3) Application Driver Layer which executes tests against the application. Popular tools like Cucumber, Concordion and FitNesse are compared across the layers in terms of their functionality and how each layer is addressed. The document also provides references and suggestions for further exploring related testing concepts.
• What is Behavior Driven Development?
• What is its value?
• How does BDD differ from Test-Driven Development?
• What is the role of the customer/product owner in BDD?
• What about teams that have traditional manual testers?
• What about teams that have developers but not testers?
• What is a good BDD test?
• What should be tested manually?
The document discusses acceptance testing frameworks, including what they are, why they are worthwhile, and what should go into one. It defines an acceptance testing framework as one that defines the format for expressing expectations, drives the application under test, executes the tests, and reports results. Frameworks help avoid issues like brittle tests and performance problems that commonly occur with tools like Selenium. Effective frameworks have components like a runner, integration, configuration, reporting, logging, and a domain-specific language. The real value is realized by integrating frameworks with continuous integration to provide timely test results. Several open source and commercial frameworks are described.
This document provides an overview of single page applications (SPAs) and AngularJS. It discusses why SPAs are useful, how they work, and key aspects of AngularJS like data binding, directives, routing, and dependency injection. Code samples are presented to demonstrate basic concepts like data binding, controllers, filters, and building an e-commerce application with routing and services. Future sessions are proposed to cover integration with Node.js backends, testing with Karma, and custom directives.
The document provides an overview of getting started with Selenium and outlines 8 steps to write automated tests:
1. Define a test strategy by determining what to test and which browsers to support
2. Choose a programming language like Java and set up dependencies
3. Learn Selenium fundamentals like locating elements and common actions
4. Write a first test to log in to a sample site
5. Create page objects and a base page to make tests reusable and maintainable
6. Add waits to make tests more resilient when waiting for elements
7. Set up a test harness for centralized setup/teardown, reporting and parallelization
8. Add cross-browser testing by using browser drivers locally or remotely
This document provides a 10 step guide to using Selenium successfully. It begins by defining a test strategy and choosing a programming language. It then covers Selenium fundamentals like locators and common actions. Steps include writing the first test, implementing page objects, making tests resilient with waits, and adding cross-browser execution. The guide also discusses test frameworks, continuous integration, and finding additional information. The overall goal is to write reusable, maintainable tests that run across browsers to provide automated feedback and catch issues early.
Promoting Agility with Running Tested Features - Lightening TalkCamille Bell
This short Lighting Talk introduces the Running Tested Feature (RTF) metric, a wonderfully useful metric that's easy to collect and promotes agility. It provides examples of RTF when development has steady progress and when SW breaks. This talk also discusses what happens when people try to game the RTF metric.
The Running Tested Features metric provides developers, managers and customers alike with a clear, unambiguous gauge of real software development progress. Usable on any kind of development project, RTF’s focus on outcome instead of process makes RTF especially fit for Agile projects. Because RTF can be used with both Agile and Waterfall projects, RTF makes an excellent progress metric for teams transitioning to Agile.
Testing for Agility: Bringing Testing into EverythingCamille Bell
The document discusses testing in an agile environment. It covers:
- Bringing testing into all aspects of development, not just as a separate phase.
- The problems that can arise from using a "waterfall" testing approach of waiting until late in the process to test, rather than continuous testing.
- How agile practices like test-driven development, behavior-driven development, and continuous integration can help transform testing practices from waterfall to more iterative and collaborative approaches.
The document discusses using examples and acceptance criteria to define requirements for software development. It recommends collaborating with business analysts, developers and testers to define examples that specify desired system behaviors in a clear and executable way. Automating acceptance tests based on these examples helps communicate requirements, verify functionality and allow for faster development cycles and deployments. Challenges include maintaining the tests and ensuring they don't become brittle. Strategies like minimizing end-to-end tests and focusing on key user journeys can help address these challenges.
Want to learn how to use Selenium from the ground up? This presentation will show you how to start from nothing and build out a well factored, maintainable, resilient, and parallelized set of tests that will run locally, on a Continuous Integration server, and in the cloud. These tests will not only work well, but exercise relevant functionality that matters to the business.
Growing Manual Testers into AutomatorsCamille Bell
Manual testing can't keep up with modern software development. Tests generated by Capture/Playback tools don't work either as these tests become brittle and break. Instead working with business and development testers need to create acceptance criteria that drives product development. To become automators testers need new tools. Testers need new ways of working. Testers need new skills. And the organization needs to support your testers growth. Here is how I and others have made it work.
Acceptance Test Driven Development With Spec Flow And FriendsChristopher Bartling
The document discusses Acceptance Test Driven Development (ATDD) using SpecFlow and other tools. SpecFlow is a .NET framework that allows writing acceptance tests in a business-readable language and generates automated tests. Features describe system functionality through scenarios, and SpecFlow generates tests from scenarios. The document also discusses related tools like WatiN and WebAii for browser automation, best practices, and includes a demo of an ATDD-developed Net Present Value calculator.
A presentation that guides you through the stages of testing your Java enterprise application. Finally it shows you that Arquillian is the best tool for that
Test and Behaviour Driven Development (TDD/BDD)Lars Thorup
In this introduction to Test Driven Development (TDD) or Behaviour Driven Development (BDD) we give a high level description of what it is and why it is useful for developers. Then we go into some details on stubs and mocks, test data, UI testing, SQL testing, JavaScript testing, web services testing and how to start doing TDD/BDD on an existing code base.
Charles Nurse, a senior architect at DotNetNuke Corporation, presented on using behavior-driven development (BDD) with Visual Studio 2010, SpecFlow, and WATIN. He began with an introduction to BDD and its practices. He then discussed using Gherkin syntax to define tests in natural language and explained how SpecFlow bridges communication between domain experts and developers. Finally, he demonstrated how to automate tests using the WATIN browser automation framework in SpecFlow scenarios.
Adapting Agility: Getting your Agile Transformation UnstuckCamille Bell
In this presentation, I explore many common Agile transformation issues and what you can do about them. I cover challenges with customers, technical process, organizational hurdles, prioritization, agile requirements, etc. Some of the topics include:
o No single Product Owner in Scrum.
o No on-site customer for Extreme Programming.
o The user stories are too big.
o The user stories are too vague.
o Bug count is going up or not going down.
o Customer/Stakeholders/PO never choose technical stories for next iteration/sprint.
o Customer/Stakeholders/PO won't take the time to prioritize their backlog.
o Even though story points match prior velocity, there seems to be too much work.
o Stand-up or Scrum meetings take forever.
o Stand-up or Scrum meetings are short, but no one talks about real problems.
o Management doesn't value removing impediments quickly.
o Velocity seems to be slowing down.
o So many hoops to jump through that it takes forever to get anything done.
This document discusses flow behavior of particulate solids in bunkers and hoppers. It contains the following key points:
1. Mass flow and core flow are the two main types of particulate flow in hoppers. Mass flow avoids channeling while core flow can lead to channeling.
2. For mass flow hoppers, the hopper angle must be greater than the effective angle of internal friction. For core flow hoppers, channeling can be avoided by proper design based on parameters like wall friction angle, internal friction angle, and minimum slot width.
3. Bridging is another flow problem that can be avoided by ensuring minimum particle size, bulk density, hopper shape, and slot dimensions based on
Common asp.net design patterns aspconf2012Steven Smith
This document discusses common ASP.NET design patterns. It provides an overview of several design patterns including singleton, factory, repository, dependency injection, and MVC. It also demonstrates these patterns in code examples and discusses when to use certain patterns over others. Real world examples are given and it encourages the use of design patterns to reduce coupling and improve code organization, testability, and maintenance.
The document discusses Selenium and Specflow, which are tools for automating browser testing and behavior-driven development. Selenium allows automating browsers through its WebDriver API, while Specflow uses Gherkin syntax like Given, When, Then to describe test cases in plain language. The document provides code examples and tips for thinking in behaviors rather than actions when using these tools, and recommends additional tools like NUnit and page object modeling to create robust and maintainable test automation.
Working Effectively with Legacy Code was presented at the 2012 DC Agile Engineering Conference on 12/7/2012 by Excella Managing Consultant Roberto Hernandez-Pou (@hernandezrobert).
Power-Up Your Test Suite with OLE Automation by Joshua RussellQA or the Highway
- Power-Up Your Test Suite With OLE Automation discusses using OLE Automation and the combination of Ruby and WIN32OLE for test automation of native Windows applications like Excel, Internet Explorer, and mainframe terminal emulators.
- OLE Automation allows automation of tasks on Windows applications through Microsoft's Automation interface when other popular options are unavailable. It provides access to an application's functionality through objects, properties, methods.
- Specific examples are provided for automating Excel workbooks and worksheets, controlling a mainframe terminal emulator, and integrating the automation into Cucumber scenarios. The presentation aims to demonstrate how OLE Automation can help "power up" a test suite.
The document discusses different layers of automated acceptance testing and compares different toolsets for each layer. The three layers are: 1) Acceptance Criteria Layer which defines test scenarios in a business-readable format, 2) Test Implementation Layer which implements tests against the system under test, and 3) Application Driver Layer which executes tests against the application. Popular tools like Cucumber, Concordion and FitNesse are compared across the layers in terms of their functionality and how each layer is addressed. The document also provides references and suggestions for further exploring related testing concepts.
• What is Behavior Driven Development?
• What is its value?
• How does BDD differ from Test-Driven Development?
• What is the role of the customer/product owner in BDD?
• What about teams that have traditional manual testers?
• What about teams that have developers but not testers?
• What is a good BDD test?
• What should be tested manually?
The document discusses acceptance testing frameworks, including what they are, why they are worthwhile, and what should go into one. It defines an acceptance testing framework as one that defines the format for expressing expectations, drives the application under test, executes the tests, and reports results. Frameworks help avoid issues like brittle tests and performance problems that commonly occur with tools like Selenium. Effective frameworks have components like a runner, integration, configuration, reporting, logging, and a domain-specific language. The real value is realized by integrating frameworks with continuous integration to provide timely test results. Several open source and commercial frameworks are described.
This document provides an overview of single page applications (SPAs) and AngularJS. It discusses why SPAs are useful, how they work, and key aspects of AngularJS like data binding, directives, routing, and dependency injection. Code samples are presented to demonstrate basic concepts like data binding, controllers, filters, and building an e-commerce application with routing and services. Future sessions are proposed to cover integration with Node.js backends, testing with Karma, and custom directives.
The document provides an overview of getting started with Selenium and outlines 8 steps to write automated tests:
1. Define a test strategy by determining what to test and which browsers to support
2. Choose a programming language like Java and set up dependencies
3. Learn Selenium fundamentals like locating elements and common actions
4. Write a first test to log in to a sample site
5. Create page objects and a base page to make tests reusable and maintainable
6. Add waits to make tests more resilient when waiting for elements
7. Set up a test harness for centralized setup/teardown, reporting and parallelization
8. Add cross-browser testing by using browser drivers locally or remotely
This document provides a 10 step guide to using Selenium successfully. It begins by defining a test strategy and choosing a programming language. It then covers Selenium fundamentals like locators and common actions. Steps include writing the first test, implementing page objects, making tests resilient with waits, and adding cross-browser execution. The guide also discusses test frameworks, continuous integration, and finding additional information. The overall goal is to write reusable, maintainable tests that run across browsers to provide automated feedback and catch issues early.
Promoting Agility with Running Tested Features - Lightening TalkCamille Bell
This short Lighting Talk introduces the Running Tested Feature (RTF) metric, a wonderfully useful metric that's easy to collect and promotes agility. It provides examples of RTF when development has steady progress and when SW breaks. This talk also discusses what happens when people try to game the RTF metric.
The Running Tested Features metric provides developers, managers and customers alike with a clear, unambiguous gauge of real software development progress. Usable on any kind of development project, RTF’s focus on outcome instead of process makes RTF especially fit for Agile projects. Because RTF can be used with both Agile and Waterfall projects, RTF makes an excellent progress metric for teams transitioning to Agile.
Testing for Agility: Bringing Testing into EverythingCamille Bell
The document discusses testing in an agile environment. It covers:
- Bringing testing into all aspects of development, not just as a separate phase.
- The problems that can arise from using a "waterfall" testing approach of waiting until late in the process to test, rather than continuous testing.
- How agile practices like test-driven development, behavior-driven development, and continuous integration can help transform testing practices from waterfall to more iterative and collaborative approaches.
The document discusses using examples and acceptance criteria to define requirements for software development. It recommends collaborating with business analysts, developers and testers to define examples that specify desired system behaviors in a clear and executable way. Automating acceptance tests based on these examples helps communicate requirements, verify functionality and allow for faster development cycles and deployments. Challenges include maintaining the tests and ensuring they don't become brittle. Strategies like minimizing end-to-end tests and focusing on key user journeys can help address these challenges.
Want to learn how to use Selenium from the ground up? This presentation will show you how to start from nothing and build out a well factored, maintainable, resilient, and parallelized set of tests that will run locally, on a Continuous Integration server, and in the cloud. These tests will not only work well, but exercise relevant functionality that matters to the business.
Growing Manual Testers into AutomatorsCamille Bell
Manual testing can't keep up with modern software development. Tests generated by Capture/Playback tools don't work either as these tests become brittle and break. Instead working with business and development testers need to create acceptance criteria that drives product development. To become automators testers need new tools. Testers need new ways of working. Testers need new skills. And the organization needs to support your testers growth. Here is how I and others have made it work.
Acceptance Test Driven Development With Spec Flow And FriendsChristopher Bartling
The document discusses Acceptance Test Driven Development (ATDD) using SpecFlow and other tools. SpecFlow is a .NET framework that allows writing acceptance tests in a business-readable language and generates automated tests. Features describe system functionality through scenarios, and SpecFlow generates tests from scenarios. The document also discusses related tools like WatiN and WebAii for browser automation, best practices, and includes a demo of an ATDD-developed Net Present Value calculator.
A presentation that guides you through the stages of testing your Java enterprise application. Finally it shows you that Arquillian is the best tool for that
Test and Behaviour Driven Development (TDD/BDD)Lars Thorup
In this introduction to Test Driven Development (TDD) or Behaviour Driven Development (BDD) we give a high level description of what it is and why it is useful for developers. Then we go into some details on stubs and mocks, test data, UI testing, SQL testing, JavaScript testing, web services testing and how to start doing TDD/BDD on an existing code base.
Charles Nurse, a senior architect at DotNetNuke Corporation, presented on using behavior-driven development (BDD) with Visual Studio 2010, SpecFlow, and WATIN. He began with an introduction to BDD and its practices. He then discussed using Gherkin syntax to define tests in natural language and explained how SpecFlow bridges communication between domain experts and developers. Finally, he demonstrated how to automate tests using the WATIN browser automation framework in SpecFlow scenarios.
Adapting Agility: Getting your Agile Transformation UnstuckCamille Bell
In this presentation, I explore many common Agile transformation issues and what you can do about them. I cover challenges with customers, technical process, organizational hurdles, prioritization, agile requirements, etc. Some of the topics include:
o No single Product Owner in Scrum.
o No on-site customer for Extreme Programming.
o The user stories are too big.
o The user stories are too vague.
o Bug count is going up or not going down.
o Customer/Stakeholders/PO never choose technical stories for next iteration/sprint.
o Customer/Stakeholders/PO won't take the time to prioritize their backlog.
o Even though story points match prior velocity, there seems to be too much work.
o Stand-up or Scrum meetings take forever.
o Stand-up or Scrum meetings are short, but no one talks about real problems.
o Management doesn't value removing impediments quickly.
o Velocity seems to be slowing down.
o So many hoops to jump through that it takes forever to get anything done.
This document discusses flow behavior of particulate solids in bunkers and hoppers. It contains the following key points:
1. Mass flow and core flow are the two main types of particulate flow in hoppers. Mass flow avoids channeling while core flow can lead to channeling.
2. For mass flow hoppers, the hopper angle must be greater than the effective angle of internal friction. For core flow hoppers, channeling can be avoided by proper design based on parameters like wall friction angle, internal friction angle, and minimum slot width.
3. Bridging is another flow problem that can be avoided by ensuring minimum particle size, bulk density, hopper shape, and slot dimensions based on
Common asp.net design patterns aspconf2012Steven Smith
This document discusses common ASP.NET design patterns. It provides an overview of several design patterns including singleton, factory, repository, dependency injection, and MVC. It also demonstrates these patterns in code examples and discusses when to use certain patterns over others. Real world examples are given and it encourages the use of design patterns to reduce coupling and improve code organization, testability, and maintenance.
An introduction to MeteorJS with a simple chatroom app code demo.
Demo code is available at: https://github.com/MingStar/meteorjs-chatroom-demo
The slides were made, for an audience who are familiar with Ruby on Rails, yet with little experience with Node or Meteor.
As presented to the Milwaukee Alt.Net group on November 21st, 2011.
UPDATE April 19, 2012: added some domain logic organization slides using Fowler's 4 basic patterns.
ABSTRACT
This project is be designed and developed to handle Frequently Asked Questions posted to various departments in a university. The University examination branch wants to maintain all the frequently asked questions in the database subject wise, to avail them to all the students whenever necessary. They will update the questions as and when required. The primary goal of the Query Handling Service is to provide an environment that is both convenient and efficient to use in retrieving and storing the information into database..
The database system must provide the safety to the information stored, despite system crashes or attempts of unauthorized access. If data are to be shared among several users, the system must avoid possible anomalous results.
Existing System
The existing system is a manual one. When the student wants to clear his query he personally contacts the concerned person in the university. The concerned person will clear his doubt.
Disadvantages:
• Difficulty in contacting the concerned person.
• Difficult to handle more students for administrator.
• Difficulty in maintaining frequently asked questions manually
Proposed System
The Query Handling Services is to replace the existing manual system with a software solution.
The University examination branch wants to maintain all the frequently asked questions in the database subject wise, to avail them to all the students. And they will update the questions as and when required in online.
The proposed system has one super user to control the data, appointing the administrators in each department. The administrator is responsible to answer all the questions posted by students.
When the student post a question in certain department the respective administrator will answer the question and a copy of the answer will be sent to the student.
Merits of This System
• Faster processing when compared to existing one.
• Maintaining frequently asked questions
• Modifications of answers can be carried out immediately
• Administrator can handle more number of students.
• Easy maintenance of administrator details.
Modules:
• Super User
• Administrator
• Student
Super User:
super user to control the data, appointing the administrators in each department,appointing the administrator to a particular department for that he register the admin,adding a new departments like computer science, chemistry, physics, maths, etc.. At the same time he can delete the departments, adding a new topic to particular department. At the same time he delete the added topics also, adding the question with answers and storing the data in database.
Administrator:
Admin can add the question with answers and it will be stored in database for students to retrieve it.
Admin will modify the answers.
The student post a question in certain department the respective administrator will answer the question and a co
The document discusses the .NET Framework, including its architecture, components like the Common Language Runtime (CLR) and class libraries, advantages over other technologies like Java, and supported programming languages. The CLR handles tasks like memory management, security, and compilation to native code. Assemblies are fundamental deployment units. The .NET Framework provides a complete environment for developing various application types on Windows and other platforms.
Webinar is conducted by Marcin Kasz, Beacon Ambassador at Kontakt.io and Ryan Bobillo, Relationship Developer at Howler. During the webinar you will learn: - How do beacons transform retail engagement? dive into hard metrics - How to put your ideas into practice with beacon hardware? How to manage large beacon deployments? learn from others experience - Get inspired by extraordinary retail use cases! and much more...
Here are my predictions about the beacon effect:
• Beacons transform the real world into a digital channel
• It’s relatively safe since there are multiple steps required for end-users to activate beacon communications
• Consumers expect feature-rich digital experiences in the physical world
• A decrease in semiconductor costs, new mandates in marketing, and consumer adoption will fuel the adoption of beacons usage
• By 2016, beacons will be free to retailers, museums, arenas
• The profit center for beacon companies will be software, analytics, insights and consulting services
• Consumers are “warming” to the idea of trading data for enhanced experiences
• Beacons are low cost and low maintenance, as a result there will be more than 4M devices in use by end of 2018
• Beacon-delivered advertising will generate significant activity in the next 18 months
• Beacon-generated ad space will be widely available via RTB and generate $500M-plus by 2018
• Mobile phone plans will be subsidized by advertising and supported by beacon data
This document discusses and compares various technologies for mobile marketing interactions within stores, including beacons, NFC, QR codes, ultrasound, and lighting. It outlines the advantages and disadvantages of each technology, how they work, which devices they support, common uses, and constraints on user experience. Beacons are highlighted as particularly promising for in-store marketing due to their ability to send push notifications, compatibility across platforms, and potential for personalized messaging and integration with CRM systems. However, over-reliance on push notifications also poses a risk of annoying customers.
Improving the Design of Existing SoftwareSteven Smith
The document discusses improving the design of existing software by following principles like DRY, SOLID, and refactoring code using techniques such as extracting classes, methods, and interfaces. It emphasizes writing characterization tests to preserve existing behavior when refactoring, and improving code quality by reducing duplication, dependencies, and complexity over time through preventative maintenance and refactoring.
Refactoring Applications using SOLID PrinciplesSteven Smith
We’ve all heard about well-designed software projects, where things aren’t (yet) a big ball of mud that’s painful to work with, but many of us aren’t lucky enough to work on these. Nor is it an option for us to get to start a brand new “greenfield” project, where we can leave behind the legacy of spaghetti code and technical debt our current project might have.
But there is hope! By applying refactoring steps based on SOLID principles of object oriented design, we can reduce the technical debt of our existing application, improve our code quality, and hopefully make our application more enjoyable and productive to work with.
In this session, we’ll briefly introduce the SOLID principles and several design patterns, and then we’ll apply these principles and patterns by improving the design of an existing application through several refactoring steps.
Integration strategies best practices- Mulesoft meetup April 2018Rohan Rasane
The document discusses best practices for integration strategies including using an integration platform, designing integrations, and implementing resiliency patterns. It recommends having an integration platform to provide features like batch processing, loose coupling, reuse, governance, and security. When designing integrations, questions about data, users, transactions, orchestrations, and future needs should be considered. Common resiliency patterns discussed are timeouts, circuit breakers, bulkheads, retries, and idempotency.
Entity Framework: To the Unit of Work Design Pattern and BeyondSteve Westgarth
The document discusses issues with traditional ASP.NET application architectures and how the introduction of MVC helped address some problems. It then describes how the presenter implemented the Unit of Work pattern to help with testing and database consistency in their application. However, this implementation violated SOLID principles. The presenter improved the design by separating concerns into distinct layers and implementing generic repositories. This made the code more testable and decoupled from Entity Framework while better adhering to object-oriented design principles. In the end, the presenter advocates evaluating design patterns critically and continuously challenging accepted approaches.
This deck represents our current thinking about the best way to build enterprise SaaS software in 2015 - using a variety of techniques from several disciplines.
Since I wrote this I have also become very interested in resilience engineering and the notion that web developers are primarily engaged in the construction of socio-technical systems. When I rewrite this I plan to talk about how we should try to minimize mean-time-to-recover (MTTR) instead of mean-time-between-failures (MTBF), and how continuous deployment grows a safety culture around your operations.
I redacted most of the examples that illustrate these points because they use sensitive code examples or URLs. If you want to see the rest of slides, join us!
DevOps is the combination of cultural philosophies, practices, and tools that increases an organization's ability to deliver applications and services at high velocity: evolving and improving products at a faster pace than organizations using traditional software development and infrastructure management processes.
Apex Enterprise Patterns Galore - Boston, MA dev group meeting 062719BingWang77
1. The document summarizes best practices and patterns discussed at a Boston Salesforce Developers Group meeting, including triggers, controllers, SOQL, callouts, and batchable/schedulable jobs.
2. It recommends separating business logic from user interface code, using mock objects in tests to isolate units, and having a single "DatabaseJockey" class perform all DML for consistency.
3. Other tips include treating triggers like workflow rules, returning errors from controllers to the user interface, querying data once through a shared SOQL class, and abstracting callouts to external services. The takeaway was to establish patterns and evolve them over time.
This document discusses code quality and defines the three Cs of code quality - clarity, complexity, and coverage. It explains that clarity means code is well formatted, cohesive, and has descriptive naming. Complexity is measured using cyclomatic complexity to identify tightly coupled code and methods with excessive logic. Coverage shows untested parts of an application but does not guarantee quality. The document emphasizes setting standards, integrating them into workflows using tools like Code Climate, Hound CI, and Codecov, and enforcing standards through linting and breaking builds on failures.
Release software is no less important than activities that precede it.
The Continuous Delivery is a set of practices and methodologies that build an ecosystem for the software development lifecycle.
We will see how to build this ecosystem around the applications developed, for which this release activities becomes a low-risk, inexpensive, fast and predictable.
The View - Lotusscript coding best practicesBill Buchan
This document discusses best practices for LotusScript coding. It covers topics like code structure, using short logical functions, defensive programming, variable naming conventions, and ensuring variables only exist as long as needed. The goal is to write code that is maintainable, reusable, and robust. Testing practices like test-driven development and separating development, testing, and production environments are also recommended to improve quality.
This document summarizes key principles for writing clean code as outlined in the book "Clean Code" by Robert C. Martin. It discusses ideas like writing code that is easy to read and understand through use of meaningful names, small functions that do one thing well, and avoiding duplication. It also covers principles for object-oriented design like encapsulation, organization for change, and separation of concerns. Testing philosophies like test-driven development and ensuring tests are fast, independent, repeatable, self-validating, and timely are also emphasized. The overall message is that writing clean code requires attention to structure, naming, formatting and testing to produce software that is simple, well-organized and a pleasure to maintain.
Patterns and practices for building enterprise-scale HTML5 appsPhil Leggetter
Developing large apps is difficult. Ensuring that code is consistent, maintainable, testable and has an architecture that enables change is essential. As is ensuring that multiple developers – across multiple teams – can efficiently contribute to the same application. When it comes to large server-focused apps, solutions to some of these challenges have been tried and tested. But, how do you achieve this when building HTML5 single-page apps?
In this session, Phil will cover the experiences his team have had when building HTML5 apps consisting of more than 250k lines of JavaScript (plus HTML templates, CSS, image, config etc) that are contributed to by multiple teams across multiple companies. He will highlight signs to watch out for as your HTML5 SPA grows, and a set of patterns and practices that help you avoid problems. He will also explain the simple yet powerful application architecture that their HTML5 apps have that is core to ensuring they scale.
Finally, Phil will demonstrate how tooling can be used to support these patterns and practices, and enable a productive developer workflow where the first line of code is feature code, features can be developed and tested in isolation, code conflicts are avoided by grouping assets by feature, and features are composed into apps.
Critical Capabilities to Shifting Left the Right WaySmartBear
The concept of testing earlier in the SDLC isn't new, but the term "shift left" has reignited its importance. See how shifting left can help you, and how to do it right.
Test automation lessons from WebSphere Application ServerRobbie Minshall
The document discusses WebSphere testing at IBM. It provides an overview of IBM's:
- Extensive testing resources including over 200 engineers and thousands of systems.
- Daily regression testing of over 1.7 million tests.
- Transition from waterfall to agile development which reduced cycle times and resources needed for testing.
- Use of cloud resources to speed up test deployment and automation.
- Focus on creating meaningful regressions through techniques like integration acceptance tests run continuously on each build.
This document discusses why services are important in software development. It explains that putting multiple responsibilities in a single class can introduce bugs, and it is better to separate different types of tasks into different classes or services. The document then provides guidance on creating and using services in Grails, including injecting services, transaction management, and different scopes that services can have.
Best Practices for Building WordPress ApplicationsTaylor Lovett
This document provides best practices for WordPress applications, covering topics like caching, database reads/writes, search queries, maintainability, security, third-party code, teams, and workflows. It recommends tools and techniques to optimize performance, including using Redis for caching, Elasticsearch for complex queries, feature plugins, documentation, testing, linting, and managing dependencies with Composer.
Five Enterprise Best Practices That EVERY Salesforce Org Can Use (DF15 Session)Vivek Chawla
The document discusses five best practices for Salesforce development that every org should adopt: 1) adopting a standard coding style, 2) following trigger best practices, 3) following unit test best practices, 4) adopting a version of separation of concerns, and 5) adopting specific naming conventions. For each best practice, the document outlines the key benefits, common adoption challenges, and how to execute. It emphasizes establishing governance through documentation, code reviews, and team effort to successfully implement best practices.
Similar to Improving the Quality of Existing Software (20)
Clean architecture with asp.net core by ArdalisSteven Smith
Clean Architecture with ASP.NET Core
ASP.NET Core provides better support for clean, testable, maintainable architectures than any of its predecessors. Learn the underlying principles that apply to project/solution organization, how best to arrange your projects to support clean code, and how to refactor existing solutions toward this architecture. Examples will use ASP.NET Core but the principles covered apply to all languages and platforms.
About Steve
Steve Smith (@ardalis) is an entrepreneur and software developer with a passion for building quality software as effectively as possible. Steve has published several courses on Pluralsight, covering DDD, SOLID, design patterns, and software architecture. He’s a Microsoft ASP.NET MVP and Insider, a frequent speaker at developer conferences, an author, and a trainer. Steve works with companies that want to avoid the trap of technical debt by helping their teams deliver quality software, quickly. Steve and his team have been described by clients as a “force multiplier”, amplifying the value of existing development teams. Steve’s client list includes Microsoft, Quicken Loans, Celina Insurance, and many other satisfied customers.
Finding Patterns in the Clouds - Cloud Design PatternsSteven Smith
The document discusses the evolution of web application architectures from single server deployments to modern cloud-native microservice architectures. It covers how early web apps faced challenges as demand grew that led to adopting caching, load balancing, and the cloud. It then discusses how further scaling issues were addressed through containers, microservices, and patterns like API gateways and circuit breakers. Key lessons are around adopting cloud-native patterns to improve performance, scalability, resilience and developer productivity for applications.
Introducing domain driven design - dogfood con 2018Steven Smith
DDD provides a set of patterns and practices for tackling complex business problems with software models. Learn the basics of DDD in this session, including several principles and patterns you can start using immediately even if your project hasn't otherwise embraced DDD. Examples will primarily use C#/.NET.
Design Pattern Mastery - Momentum Dev Con 19 Apr 2018Steven Smith
Design patterns help developers and teams solve problems using proven approaches. In this talk, you'll learn how to solve a series of real world problems by applying patterns. Not only do patterns help individual developers solve particular problems, but they also enable teams to discuss design decisions using a richer, more descriptive language. By the end, you'll have some concrete tools you can apply, and hopefully the desire to master more patterns as you continue to improve!
Introducing Domain Driven Design - codemashSteven Smith
DDD provides a set of patterns and practices for tackling complex business problems with software models. Learn the basics of DDD in this session, including several principles and patterns you can start using immediately even if your project hasn't otherwise embraced DDD. Examples will primarily use C#/.NET.
Design patterns provide common templates for solving similar problems. They also provide a higher-level language for software developers to use to describe approaches they might choose when designing part of an application. This session introduces and applies several patterns useful to web application developers. Examples will primarily use C#/.NET.
Given at DogFoodCon 2016 in Columbus, Ohio
Domain Events, a Domain-Driven Design (DDD) pattern, provide a way to decouple your code. Rather than hard-coding a series of steps that must be completed in response to a particular action a user takes, that action can raise an event. Handlers for an event can be added without changing the code responsible for raising the event, resulting in a more extensible design. Coupled with SignalR or push notifications in the UI layer, domain events can trigger live updates, even to web-based applications and mobile apps.
ASP.NET 5 has been redesigned with an emphasis on speed, composability, and cross-platform support. The new ASP.NET is leaner, faster, open source, and fixes many of the inconsistencies and problems present in ASP.NET today.
Domain Events, a Domain-Driven Design (DDD) pattern, provide a way to decouple your code. Rather than hard-coding a series of steps that must be completed in response to a particular action a user takes, that action can raise an event. Handlers for that event can be added without changing the code responsible for raising the event, resulting in a more extensible design. Coupled with SignalR in the UI layer, domain events can trigger updates to the application without the user having to refresh the application.
My 2004 deployment to Iraq and missions as a combat engineer platoon leader in support of EOD missions. Presented to Ravenna, Ohio Daughters of the American Revolution chapter 18 October 2014
This document discusses Domain-Driven Design (DDD) and how it can be applied to ASP.NET MVC projects. It covers DDD concepts like ubiquitous language, bounded contexts, entities, value objects, domain services, and domain events. It also discusses how to structure an MVC project to separate the domain model from the rest of the application using patterns like layered architecture and ports and adapters. The document argues that DDD can provide benefits like flexibility, manageable complexity, and centralized business logic, though it may require more time and effort to implement.
Refactoring with SOLID Principles (FalafelCon 2013)Steven Smith
We’ve all heard about well-designed software projects, where things aren’t (yet) a big ball of mud that’s painful to work with, but many of us aren’t lucky enough to work on these. Nor is it an option for us to get to start a brand new “greenfield” project, where we can leave behind the legacy of spaghetti code and technical debt our current project might have.
But there is hope! By applying refactoring steps based on SOLID principles of object oriented design, we can reduce the technical debt of our existing application, improve our code quality, and hopefully make our application more enjoyable and productive to work with.
In this session, we’ll briefly introduce the SOLID principles and several design patterns, and then we’ll apply these principles and patterns by improving the design of an existing application through several refactoring steps.
Common ASP.NET Design Patterns - Telerik India DevCon 2013Steven Smith
This document provides an overview of common ASP.NET design patterns, including Singleton, Strategy, Repository, Proxy, Command, and Factory patterns. It discusses the intent, structure, and usage of each pattern. Code examples and references are also provided. Real-world examples are discussed to demonstrate how design patterns can be used to address issues like tight coupling and improve code quality during refactoring or initial design.
Refactoring with SOLID - Telerik India DevCon 2013Steven Smith
The document discusses refactoring applications using SOLID principles. It covers how software can deteriorate over time through duplication, excess coupling, quick fixes, and hacks. It advocates using preventative maintenance through refactoring to eliminate duplication and simplify design, as well as automated tests to verify correctness and avoid regressions. The document outlines the refactoring process and introduces characterization tests. It then covers each SOLID principle - Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion - and provides examples of how to apply them through various refactorings.
Pair programming involves two programmers working together at one computer. One person acts as the driver who types code while the other navigates and reviews. It has benefits like catching mistakes earlier, improving design quality, transferring knowledge between partners, and creating a stronger sense of team. While there is initially a 15% overhead in time, studies show this is outweighed by fewer defects and a more flexible system in the long run. Effective pair programming requires collaboration, respect, communication and regularly alternating roles.
The document discusses anti-patterns and worst practices in software development. Some examples covered include static cling pattern, flags over objects, premature optimization, copy-paste-compile, and reinventing the wheel. It also shares lessons learned from experiences, such as being mindful of date times across time zones, avoiding building SQL from untrusted inputs, and not being too cute with test data. Overall, the document aims to help developers learn from the mistakes of others and adopt better practices.
Baha Majid WCA4Z IBM Z Customer Council Boston June 2024.pdfBaha Majid
IBM watsonx Code Assistant for Z, our latest Generative AI-assisted mainframe application modernization solution. Mainframe (IBM Z) application modernization is a topic that every mainframe client is addressing to various degrees today, driven largely from digital transformation. With generative AI comes the opportunity to reimagine the mainframe application modernization experience. Infusing generative AI will enable speed and trust, help de-risk, and lower total costs associated with heavy-lifting application modernization initiatives. This document provides an overview of the IBM watsonx Code Assistant for Z which uses the power of generative AI to make it easier for developers to selectively modernize COBOL business services while maintaining mainframe qualities of service.
14 th Edition of International conference on computer visionShulagnaSarkar2
About the event
14th Edition of International conference on computer vision
Computer conferences organized by ScienceFather group. ScienceFather takes the privilege to invite speakers participants students delegates and exhibitors from across the globe to its International Conference on computer conferences to be held in the Various Beautiful cites of the world. computer conferences are a discussion of common Inventions-related issues and additionally trade information share proof thoughts and insight into advanced developments in the science inventions service system. New technology may create many materials and devices with a vast range of applications such as in Science medicine electronics biomaterials energy production and consumer products.
Nomination are Open!! Don't Miss it
Visit: computer.scifat.com
Award Nomination: https://x-i.me/ishnom
Conference Submission: https://x-i.me/anicon
For Enquiry: Computer@scifat.com
Orca: Nocode Graphical Editor for Container OrchestrationPedro J. Molina
Tool demo on CEDI/SISTEDES/JISBD2024 at A Coruña, Spain. 2024.06.18
"Orca: Nocode Graphical Editor for Container Orchestration"
by Pedro J. Molina PhD. from Metadev
🏎️Tech Transformation: DevOps Insights from the Experts 👩💻campbellclarkson
Connect with fellow Trailblazers, learn from industry experts Glenda Thomson (Salesforce, Principal Technical Architect) and Will Dinn (Judo Bank, Salesforce Development Lead), and discover how to harness DevOps tools with Salesforce.
Alluxio Webinar | 10x Faster Trino Queries on Your Data PlatformAlluxio, Inc.
Alluxio Webinar
June. 18, 2024
For more Alluxio Events: https://www.alluxio.io/events/
Speaker:
- Jianjian Xie (Staff Software Engineer, Alluxio)
As Trino users increasingly rely on cloud object storage for retrieving data, speed and cloud cost have become major challenges. The separation of compute and storage creates latency challenges when querying datasets; scanning data between storage and compute tiers becomes I/O bound. On the other hand, cloud API costs related to GET/LIST operations and cross-region data transfer add up quickly.
The newly introduced Trino file system cache by Alluxio aims to overcome the above challenges. In this session, Jianjian will dive into Trino data caching strategies, the latest test results, and discuss the multi-level caching architecture. This architecture makes Trino 10x faster for data lakes of any scale, from GB to EB.
What you will learn:
- Challenges relating to the speed and costs of running Trino in the cloud
- The new Trino file system cache feature overview, including the latest development status and test results
- A multi-level cache framework for maximized speed, including Trino file system cache and Alluxio distributed cache
- Real-world cases, including a large online payment firm and a top ridesharing company
- The future roadmap of Trino file system cache and Trino-Alluxio integration
The Power of Visual Regression Testing_ Why It Is Critical for Enterprise App...kalichargn70th171
Visual testing plays a vital role in ensuring that software products meet the aesthetic requirements specified by clients in functional and non-functional specifications. In today's highly competitive digital landscape, users expect a seamless and visually appealing online experience. Visual testing, also known as automated UI testing or visual regression testing, verifies the accuracy of the visual elements that users interact with.
The Comprehensive Guide to Validating Audio-Visual Performances.pdfkalichargn70th171
Ensuring the optimal performance of your audio-visual (AV) equipment is crucial for delivering exceptional experiences. AV performance validation is a critical process that verifies the quality and functionality of your AV setup. Whether you're a content creator, a business conducting webinars, or a homeowner creating a home theater, validating your AV performance is essential.
Liberarsi dai framework con i Web Component.pptxMassimo Artizzu
In Italian
Presentazione sulle feature e l'utilizzo dei Web Component nell sviluppo di pagine e applicazioni web. Racconto delle ragioni storiche dell'avvento dei Web Component. Evidenziazione dei vantaggi e delle sfide poste, indicazione delle best practices, con particolare accento sulla possibilità di usare web component per facilitare la migrazione delle proprie applicazioni verso nuovi stack tecnologici.
Unlock the Secrets to Effortless Video Creation with Invideo: Your Ultimate G...The Third Creative Media
"Navigating Invideo: A Comprehensive Guide" is an essential resource for anyone looking to master Invideo, an AI-powered video creation tool. This guide provides step-by-step instructions, helpful tips, and comparisons with other AI video creators. Whether you're a beginner or an experienced video editor, you'll find valuable insights to enhance your video projects and bring your creative ideas to life.
Superpower Your Apache Kafka Applications Development with Complementary Open...Paul Brebner
Kafka Summit talk (Bangalore, India, May 2, 2024, https://events.bizzabo.com/573863/agenda/session/1300469 )
Many Apache Kafka use cases take advantage of Kafka’s ability to integrate multiple heterogeneous systems for stream processing and real-time machine learning scenarios. But Kafka also exists in a rich ecosystem of related but complementary stream processing technologies and tools, particularly from the open-source community. In this talk, we’ll take you on a tour of a selection of complementary tools that can make Kafka even more powerful. We’ll focus on tools for stream processing and querying, streaming machine learning, stream visibility and observation, stream meta-data, stream visualisation, stream development including testing and the use of Generative AI and LLMs, and stream performance and scalability. By the end you will have a good idea of the types of Kafka “superhero” tools that exist, which are my favourites (and what superpowers they have), and how they combine to save your Kafka applications development universe from swamploads of data stagnation monsters!
Photoshop Tutorial for Beginners (2024 Edition)alowpalsadig
Photoshop Tutorial for Beginners (2024 Edition)
Explore the evolution of programming and software development and design in 2024. Discover emerging trends shaping the future of coding in our insightful analysis."
Here's an overview:Introduction: The Evolution of Programming and Software DevelopmentThe Rise of Artificial Intelligence and Machine Learning in CodingAdopting Low-Code and No-Code PlatformsQuantum Computing: Entering the Software Development MainstreamIntegration of DevOps with Machine Learning: MLOpsAdvancements in Cybersecurity PracticesThe Growth of Edge ComputingEmerging Programming Languages and FrameworksSoftware Development Ethics and AI RegulationSustainability in Software EngineeringThe Future Workforce: Remote and Distributed TeamsConclusion: Adapting to the Changing Software Development LandscapeIntroduction: The Evolution of Programming and Software Development
Photoshop Tutorial for Beginners (2024 Edition)Explore the evolution of programming and software development and design in 2024. Discover emerging trends shaping the future of coding in our insightful analysis."Here's an overview:Introduction: The Evolution of Programming and Software DevelopmentThe Rise of Artificial Intelligence and Machine Learning in CodingAdopting Low-Code and No-Code PlatformsQuantum Computing: Entering the Software Development MainstreamIntegration of DevOps with Machine Learning: MLOpsAdvancements in Cybersecurity PracticesThe Growth of Edge ComputingEmerging Programming Languages and FrameworksSoftware Development Ethics and AI RegulationSustainability in Software EngineeringThe Future Workforce: Remote and Distributed TeamsConclusion: Adapting to the Changing Software Development LandscapeIntroduction: The Evolution of Programming and Software Development
The importance of developing and designing programming in 2024
Programming design and development represents a vital step in keeping pace with technological advancements and meeting ever-changing market needs. This course is intended for anyone who wants to understand the fundamental importance of software development and design, whether you are a beginner or a professional seeking to update your knowledge.
Course objectives:
1. **Learn about the basics of software development:
- Understanding software development processes and tools.
- Identify the role of programmers and designers in software projects.
2. Understanding the software design process:
- Learn about the principles of good software design.
- Discussing common design patterns such as Object-Oriented Design.
3. The importance of user experience (UX) in modern software:
- Explore how user experience can improve software acceptance and usability.
- Tools and techniques to analyze and improve user experience.
4. Increase efficiency and productivity through modern development tools:
- Access to the latest programming tools and languages used in the industry.
- Study live examples of applications
DECODING JAVA THREAD DUMPS: MASTER THE ART OF ANALYSISTier1 app
Are you ready to unlock the secrets hidden within Java thread dumps? Join us for a hands-on session where we'll delve into effective troubleshooting patterns to swiftly identify the root causes of production problems. Discover the right tools, techniques, and best practices while exploring *real-world case studies of major outages* in Fortune 500 enterprises. Engage in interactive lab exercises where you'll have the opportunity to troubleshoot thread dumps and uncover performance issues firsthand. Join us and become a master of Java thread dump analysis!
5. Technical Debt
• Low quality code and shortcuts in our applications
• Technical debt, like real debt, has direct cost to pay off as well as interest
http://deviq.com/technical-debt/
10. “
”
You don’t need permission to practice basic hygiene
when you write software.
http://ardalis.com/when-should-you-refactor/
Make cleaning up your code something you do as part of writing code.
13. The Refactoring Process
• Verify existing behavior
• Write CharacterizationTests if none exist
• Find test points
• Break dependencies
• Apply Refactoring
• Confirm existing behavior is preserved
14. CharacterizationTests
Process
1. Write a test you know will fail
2. Use the output of the failing test to determine the existing behavior to
assert
3. Update the test with the new value/behavior
4. Run the test again – it should now pass
15.
16. S O L I DPrinciples
http://flickr.com/photos/kevinkemmerer/2772526725/
21. Common Refactorings
• Replace Magic Number/String
• Parameterize Method
• Pull Up Field
• Pull Up Method
• Replace Conditional With Polymorphism
• Introduce Method
22. Common Source of Repetition: Role Checks
if(user.IsInRole(“Admins”)
{
// allow access to resource
}
// favor privileges over role checks
// ardalis.com/Favor-Privileges-over-Role-Checks
var priv = new ContentPrivilege(user, article);
if(priv.CanEdit())
{
// allow access
}
23. Visual Studio Code Clones
• Find similar blocks of code in your projects/solution
• Can detect matches that are similar but vary in small ways (like variable
names)
• Available inVS2015 Premium and Ultimate
24.
25. Single Responsibility Principle
The Single Responsibility Principle states that every object should have a single
responsibility, and that responsibility should be entirely encapsulated by the
class.
Wikipedia
There should never be more than one reason for a class to change.
Robert C. “Uncle Bob” Martin
26. What is a responsibility?
“My CustomerManager class is only responsible for
anything to do with a Customer.That follows SRP, right?”
27. Examples of Responsibilities
• Persistence
• Validation
• Notification
• Error Handling
• Logging
• Class Selection / Construction
• Formatting
• Parsing
• Mapping
28. Dependency and Coupling
• Excessive coupling makes changing legacy software difficult
• Breaking apart responsibilities and dependencies is a large part of working
with existing code
36. Open / Closed Principle
The Open / Closed Principle states that software entities (classes, modules,
functions, etc.) should be open for extension, but closed for modification.
Wikipedia
37. Open / Closed Principle
Open to Extension
New behavior can be added in the future
Closed to Modification
Changes to source or binary code are not required
Dr. Bertrand Meyer originated the OCP term in his 1988 book, ObjectOrientedSoftwareConstruction
42. OCP OK
private IEnumerable<ICustomerRule> _rules;
public bool IsSpecialCustomer(Customer customer)
{
foreach(var rule in _rules)
{
if(rule.Evaluate(customer) == false) return false;
}
return true;
}
43.
44. Liskov Substitution Principle
The Liskov Substitution Principle states that Subtypes must be substitutable for
their base types.
Agile Principles, Patterns, and Practices in C#
Named for Barbara Liskov, who first described the principle in 1988.
48. Nulls Break Polymorphism
foreach(var employee in employees)
{
if(employee == null)
{
// print not found message
break;
}
Helpers.PrintEmployee(employee);
} http://ardalis.com/nulls-break-polymorphism
49.
50. Interface Segregation Principle
The Interface Segregation Principle states that Clients should not be
forced to depend on methods they do not use.
Agile Principles, Patterns, and Practices in C#
Corollary:
Prefer small, cohesive interfaces to “fat” interfaces
55. ISP OK (i.e. to support CQRS)
public IRepository<T> : IReadRepository<T>,
IWriteRepository<T>
{ }
public IReadRepository<T>
{
T GetById(int id);
IEnumerable<T> List();
}
public IWriteRepository<T>
void Create(T item);
void Update(T item);
void Delete(T item);
}
Existing implementations of
IRepository<T> are
unaffected by pulling out
smaller interfaces!
No existing code breaks!
56.
57. Dependency Inversion Principle
High-level modules should not depend on low-level modules. Both
should depend on abstractions.
Abstractions should not depend on details. Details should depend on
abstractions.
Agile Principles, Patterns, and Practices in C#
58. Dependency Inversion Principle
• Depend on Abstractions
• Interfaces, not concrete types
• Inject Dependencies into Classes
• Structure Solution so Dependencies FlowToward Core
• Onion Architecture (a.k.a. Ports and Adapters, a.k.a. Hexagonal Architecture)
60. Common Dependencies
• Framework
• Third Party Libraries
• Database
• File System
• Email
• Web Services
• System Resources (Clock)
• Configuration
• The new Keyword
• Static methods
• Thread.Sleep
• Random
See also responsibilities:
• Persistence
• Validation
• Notification
• Error Handling
• Logging
• Class Selection /
Construction
• Formatting
• Parsing
• Mapping
61. Common Refactorings
• Extract Class
• Extract Interface / Apply Strategy Pattern
• Extract Method
• Introduce Service Locator / Container
63. Hidden Dependencies
• Checkout Depends on an available SMTP server, but the class doesn’t reflect
this
• Follow the Explicit Dependencies Principle
• http://deviq.com/explicit-dependencies-principle/
69. Self-Improvement and Quality
• How fast can you produce:
• Code you believe to be of high quality
• Code that maybe gets the job done, but you believe to be of low quality
• Which one can you produce more quickly?
• Why?
• How can we develop our skills and our tools so that building quality is
natural and easier than not doing so?
74. • New Coworking Space in Hudson,Ohio
• Private offices / Flex desk spaces
• Fiber internet
• Complimentary coffee / tea / water
• Great development community
• @techhubhudson
• Website online soon
Tech Hub Hudson
75. • Includes images like the ones in this presentation
• Kickstarter Successful!
• Available November 2016
• Order now:
store.DevIQ.com
2017 Software Craftsmanship Calendar
76. Books
Refactoring http://amzn.to/110tscA
Refactoring to Patterns http://amzn.to/Vq5Rj2
Working Effectively with Legacy Code http://amzn.to/VFFYbn
Code Complete http://amzn.to/Vq5YLv
Clean Code http://amzn.to/YjUDI0
Over time, neglect can turn software from well-oiled machinery into heaps of useless junk.
Typically the low quality code was left because of the need to meet deadlines, but once in place, the justification for having put it there no longer matters.
Whenever you are forced to work around the hacks, bad code, etc, in your application, the decrease in your productivity represents interest on technical debt. If you spend time refactoring the code to improve its quality, you are paying down the principal of the technical debt (and thus reducing future interest costs).
Accidental vs. Deliberate decision to incur the debt.
Reckless vs. Prudent kinds of debt incurred.
Should we spend an iteration or a month just trying to improve the quality of the system, and pay down technical debt?
What would you think if you went to your favorite restaurant, only to find that it was closed for a month, with a sign explaining that it needed to clean up things that had gotten out of hand due to neglect. Would you feel as confident about eating the product of that kitchen, knowing it had let things go so wrong that it now needed a month without producing food just to clean up the mess it had created. How do you think our customers should feel if we request time to clean up our code instead of fixing bugs or delivering new features?
By definition, refactoring attempts to improve the quality of a software application without changing its behavior. If you’re changing behavior, you’re not refactoring, you’re fixing a bug or adding a feature (hopefully – or adding a bug).
Only refactor code while your tests are passing. Make sure they still pass when you are done. Break large refactorings into small steps and test after each step.
Note that characterization tests, though they should be automated, are often not what we would think of as unit tests, or perhaps even integration tests. For instance, you could dump a log file showing the relevant state of the application, and then use that as the basis for your characterization test by comparing against it after your changes.
Avoid creating a big ball of mud system, where tracing through your code and its dependencies is like trying to unwind a tangled mess of spaghetti.
Principles provide guidance for refactoring. They provide a consistent target to aim toward.
A very common source of repetition of code is role checks. These often describe different scenarios in different circumstances. For instance, maybe administrators can do anything, but managers can access resources within their division, etc. Encapsulating the logic of CanView, CanCreate, CanEdit, etc. in privilege objects makes these rules explicit, easier to test, and gives them a single location to live in the application.
Visual Studio can quickly analyze a project and show statistics for the classes and methods in the project. The maintainability index, cyclomatic complexity, and lines of code are all great metrics to pay attention to. The ideal maintainability index is 100, but don’t expect to hit that with any code that’s doing real work. However, you should certainly able to keep it above 50.
Demo GildedRose.
Using Excel
I’m not a fan of regions. They mainly exist because at one time they were a reasonable means of hiding generated code, before we had support for partial classes and other language features to deal with this. The worst offense with regions is when they’re used within a method, like this:
(click)
They’re also bad when used at the class level for “standard” formatting of code, making it impossible to actually see what the code does, like this:
(click)
Can someone tell me what this class does?
(click)
I have a whole article devoted to why using regions is a bad habit, anti-pattern, code smell, whatever you prefer. It includes some survey results on the most common ways people use them as well. (click)
Open-Closed Principle
Software can only be open to extension in a few different axes, and each additional bit of flexibility adds complexity to the software. Thus, this flexibility should be added only when needed, not simply anticipated.
What happens when we need to add another country?
What happens when we must add another rule?
How can we refactor this so this method no longer needs to change?
Define a type to describe a rule. Move each rule into its own type. Create a collection of rules to apply and apply them.
Pass the set of rules into the IsSpecialCustomer() method’s class (or even the method itself).
Any time you find that you need to check the type of an object within a polymorphic block of code (such as a foreach), this is a sign that you are breaking LSP.
Nulls break polymorphism and violate LSP just as much as other subtypes that aren’t substitutable! Try to avoid the possibility of dealing with nulls in polymorphic code like foreach loops – consider using Null Object Pattern to address.
This is an extemely common example of the Repository design pattern. In fact, I use this exact pattern in quite a few production applications today. There’s nothing inherently wrong with this implementation on its own. However, sometimes it does violate ISP if you need to separate Commands from Queries
You can create small interfaces and compose the larger interfaces from the smaller ones if you control all of the code and you can’t simply do away with the larger interfaces. In this case, the separation of interfaces would allow us to do something like implement caching only on the read operations, and implement delayed writes using some kind of queue or message bus for the write operations.
“Legacy” N-Tier Logical Architecture
Hidden Dependencies
Extract interface
Implement interface with tightly coupled original code