This document discusses how to improve software quality through code reviews. It begins by stating the goals of code review, such as improving code quality, sharing knowledge, and educating developers. It then discusses classification of code reviews from less to more formal. The document outlines some best practices for code reviews, including having a reviewer and author, choosing reviewers strategically, and driving the review in different ways. It provides answers to common questions about organizing effective code reviews and leaves with tips, such as tracking reviewers, using checklists, and ensuring comfortable conditions for all.
We presented this library at Java Developer Conference Cairo 2012. The purpose of this library is to provide developers with the capability to do Data Driven Testing on Android.
Presentation from XP Days Ukraine (December, 2011) and QADnepr Mini Conference (Dnepropetrovsk, October 2011) about true role of testers and ways to fix development process to avoid their participation in usual stages of the quality control chain.
Introduction to the fundamentals of eXtreme programming (XP). XP is a software development approach which stresses on improving software quality and respond according to changing business requirements.
The document provides guidance for becoming a senior software tester, covering areas such as English language skills, understanding processes like Agile and Scrum, test estimation, test automation frameworks, testing best practices, collaboration skills, and communication skills. It recommends books, presentations, videos and other resources on these topics to help testers improve and grow into senior roles. The document emphasizes the importance of continuous learning, taking initiative, and not being afraid to take on more responsibility.
DevOps & Technical Agility: From Theory to PracticeLemi Orhan Ergin
This is the content I presented in meetups for giving brief information about Agile, Devops, Software Craftsmanship, Opertions and Continuous Delivery and their connection with each other.
Software Craftsmanship VS Software EngineeringAndy Maleh
Software craftsmanship and software engineering both aim to deliver high-quality, reliable software, but differ in their approaches. Software engineering focuses on macro goals and processes, while craftsmanship emphasizes mastering skills through experience. Both are used at Groupon, where engineering practices like architecture, testing and iteration are combined with craftsmanship techniques including apprenticeships and pair programming.
How hard can it be to start a software development project? It can be very intimidating to start at the blank page.
This talk offers some ideas how to make getting started less scary and more enjoyable, from the first keyboard stroke to a working usable system.
This document provides an introduction to test driven development (TDD). It begins with an agenda and background on the presenter. It then covers the shift-left mindset of testing early in development. Lean thinking principles like eliminating waste and poke-yoke testing techniques are discussed. The document dives into TDD methodology including writing tests before code, best practices like the three laws of TDD, and test case design techniques. Advantages like improved code quality and maintaining are highlighted. Finally, it outlines a workshop on a string sum coding exercise and advanced TDD topics like test pyramids and multi-layer application testing.
Software Craftsmanship - It's an ImperativeFadi Stephan
The document discusses the history and principles of software craftsmanship. It outlines how software craftsmanship values not only working software but well-crafted software, and focuses on steadily adding value through a community of professionals. The document presents the Manifesto of Software Craftsmanship and its emphasis on technical excellence, good design, automation, clean code, and continuous improvement.
Automated Testing with Logic Apps and SpecflowBizTalk360
At Integration Monday, we have had feedback from the audience that people are struggling with understanding how to do automated testing with Logic Apps. Back in the day Mike Stephenson wrote a lot of guidance about automated testing & unit testing for BizTalk. So he took up the challenge of trying to help out on this one.
In this session, we will discus some of the challenges around testing Logic Apps and then we will work through some examples of how testing can be performed and finally we will look at an approach which should put us in a solid place to be able to test Logic Apps both as an individual developer and via an automated build.
Implementing Test Automation in Agile ProjectsMichael Palotas
This document discusses test automation practices at eBay. It begins by providing facts about eBay as a company and platform. It then outlines eBay's approach to test automation, which involves designing automated tests using test aspects, modeling the business domain layer, and implementing tests using Selenium. The document advocates for a lean approach to test automation to avoid technical debt and waste. It emphasizes automating regression tests first before expanding to other test types and executing tests in parallel using a Selenium Grid for faster feedback.
I attended the Tabara de Testare testing group on 3rd February 2015 to present "Lessons Learned When Automating. A live stream from UK to Romania.
http://compendiumdev.co.uk/page/tabaradetestare201602
I've been asked some very challenging questions about lessons learned, and how decisions are made during the process of automating and performing technical testing. In this webinar I'm going to answer them based on my experience. We'll discus how we know 'what to automate' which means we have to split our analysis into 'detection' and 'testing'. We'll cover lessons learned from solving problems, and making mistakes, and steps we can take during the problem solving process e.g. for intermittent failures, and possible tool bugs. We'll discuss abstraction levels and the different levels of the technology stack to automate: how to do it, and how we make the decisions. We'll discuss coding primarily the differences, and the overlap, between the needs for coding for testing and coding for production deployment. We'll also cover some WebDriver specific answers to some of these questions. I'm also going to describe books and techniques that have helped me over the years when trying to deal with these questions on production projects.
This document provides an overview of a training on test automation. It outlines a 4 stage approach to test automation:
1) Stage 1 involves writing basic scripts to test a site without using page objects or a testing framework.
2) Stage 2 introduces Cucumber for writing tests in a plain English format without code.
3) Stage 3 focuses on writing specifications that can be used across multiple platforms and applications.
4) Stage 4 covers implementing page objects to hide browser interactions and provide a more intuitive task-based testing interface.
The training covers each stage through demonstrations and exercises with the goal of helping attendees better understand common mistakes and approaches to test automation.
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.
The document discusses building an effective test team. It recommends hiring people with a mix of hard and soft skills at different experience levels who share common goals and are willing to teach and learn from each other. Soft skills like learning, sharing knowledge, explaining viewpoints, negotiating, and handling conflicts are emphasized as being more important than hard skills. The document provides examples of how to define needed hard skills and evaluate candidates based on their skills and experience levels. It also shows an example skills assessment of potential candidates for both manual and automation testing roles.
Agile Software Development in Practice - A Developer PerspectiveWee Witthawaskul
This document provides an overview of agile software development practices from a developer perspective. It recommends adopting agile practices to increase productivity and recommends Scrum and XP as agile frameworks. It describes common agile practices like user stories, daily standups, iteration planning, testing practices like TDD, mocks and continuous integration to automate testing.
This document discusses software development methodologies like Waterfall and Agile. It emphasizes that while Waterfall is still dominant, Agile is better suited for small organizations because it focuses on delivering working software frequently. It also stresses the importance of good programming practices like using intention-revealing names, avoiding side effects, and test-driven development (TDD) to produce understandable and testable code. Finally, it outlines various tools that can be used for project management, version control, testing, continuous integration, and monitoring in the development process.
This document provides an overview of agile methodology and several agile frameworks. It begins with a brief history of the traditional waterfall model and its limitations. It then introduces the agile manifesto and some core agile principles. Several agile frameworks are described at a high level, including scrum, kanban, extreme programming, and others. Key practices of scrum and extreme programming like iterations, user stories, stand-up meetings, and test-driven development are defined. The document aims to give the reader a broad understanding of agile concepts and some of the most commonly used agile frameworks and practices.
One of the main hindrances to teams being able to respond rapidly to new features are technical problems resulting from bad coding practices, also known as technical debt. Melissa and Brett will cover Agile tools and practices that help development teams write better code and increase maintainability. Topics that will be covered include:
Pair programming
Automated Unit Testing
Refactoring
Test-Driven Development
Agile Architecture
Basic concept on Systems/Software Analysis, Design & Development, how software engineering, large projects are done, collaborated, best practices & standards.
The document discusses professionalizing the front-end developer role. It covers:
1. The responsibilities of a front-end developer in bringing a designer's static design to life, separating concerns between front-end and back-end teams through an API.
2. Techniques, tools, languages, and frameworks a front-end developer uses like test-driven development, automation workflows, preprocessors, frameworks, and more.
3. Introductions to Angular and React, including their conceptual overviews, classic request flows, learning curves, and how to think in the "React way" through components, state, data flow, and more.
XP is an agile software development methodology based on values of communication, simplicity, feedback, courage, and respect. It emphasizes coding, testing, listening, and designing activities. Core practices include pair programming, test-driven development, small releases, refactoring, and collective code ownership. Testing is done through automated unit tests written by developers and acceptance tests defined by customers.
A modern architecturereview–usingcodereviewtools-ver-3.5SSW
For any project that is critical to the business, it’s important to do ‘Modern Architecture Reviews’. Being an architect is fun, you get to design the system, do ongoing code reviews, and play the bad ass. It is even more fun when using modern cool tools.
Amanda Cinnamon - Treat Your Code Like the Valuable Software It IsRehgan Avon
2018 Women in Analytics Conference
https://www.womeninanalytics.org/
Data analysts create millions of lines of elegant, powerful code every year. However, because software development is not seen as their primary role, best practices of software engineering often fall to the wayside. Many data analysts are self-taught programmers who haven’t been exposed to tools like version control software, unit testing suites, and System Development Life Cycle (SDLC) processes. Popular software engineering concepts such as Don’t Repeat Yourself (DRY), design patterns, and modularization can vastly improve the quality and efficiency of analytics projects. This talk will provide a high-level introduction to these topics, and will focus on providing resources for additional learning.
The document discusses the evolution of agile teams from having no tests to implementing behavior-driven development and domain-driven design using Behat acceptance tests. It provides examples of using Behat scenarios to drive the development of a domain model for a messaging system without frameworks or controllers. The benefits are a simple, framework-agnostic domain model that is easy to understand and test and separates business logic from the user interface layers.
All you need is fast feedback loop, fast feedback loop, fast feedback loop is...Nacho Cougil
Join us in exploring the importance of having an agile feedback loop in software development.
By minimizing the time between code changes and receiving feedback, teams can accelerate bug detection, improve software quality, enhance collaboration, and increase happiness.
We'll discuss key components like continuous integration, automated testing, monitoring, and best practices and strategies. Discover the benefits of implementing DORA metrics, running experiments, using feature flags, and saving costs. Prepare to be inspired by real-life cases and understand how a fast feedback loop can revolutionize your development process.
Participants will be encouraged to adopt a "fast feedback loop" mentality, emphasizing the transformative impact it can have on the efficiency and effectiveness of software development and, at the end, be prepared to sing in chorus (emulating a famous band): "Fast feedback loop, fast feedback loop, fast feedback loop is all you need!" 😉
---
Presentation shared at WeAreDevelopers World Congress '24
Feedback form:
https://bit.ly/feedback-fast-feedkback-loop
Alex Bolboacă: Usable Software Design at I T.A.K.E. Unconference 2015Mozaic Works
The document discusses usable software design, which aims to create code structures that are easy for developers to use. It defines usable software design as having five key qualities: learnability, efficiency, memorability, minimizing errors, and satisfaction. It provides hints on how to design for each quality, such as using consistent naming, modular code with clear APIs, and automated testing. The document argues that usable design can improve integration of new developers, speed up typical tasks, reduce mistakes, and increase motivation. It stresses starting with defining developer personas and a team agreement on usability goals.
Cucumber and RSpec are testing tools used in behavior-driven development and test-driven design. Cucumber tests user stories written in a business-readable language and converts them to automated acceptance tests. RSpec is a testing framework that allows writing unit tests in a domain-specific language. Together, Cucumber and RSpec support a test-first approach to agile software development where user requirements are tested through acceptance tests before code is written to pass unit tests.
Managing a team and project are quite synonymous. Especially, teams require effective distribution of responsibility / roles. Once that is setup, a proper process guides people to make progress. All this fits into a product lifecycle, which is essential to develop the right product, in the right way, and deliver it at the right time.
Usability testing involves having representative users complete typical tasks while observers take notes on their experiences. Early testing prevents costly late-stage changes. While large companies use expensive labs, low-budget testing can also provide useful insights through informal sessions. The results should be reviewed collaboratively to improve the interface design and ensure it meets users' needs.
Agile Methodologies And Extreme Programming - Svetlin NakovSvetlin Nakov
1. Agile development and Extreme Programming (XP) are methodologies that focus on iterative development, collaboration, and adaptability.
2. XP consists of 12 key practices including simple design, test-driven development, pair programming, and small releases. It aims to improve quality, reduce risks, and adapt to changing requirements.
3. While XP works well for some projects and teams, its practices may not be suitable or flexible enough for all situations. Developers should understand the principles behind XP and tailor practices as needed for their specific projects.
Software developers love tools for coding, debugging, testing, and configuration management. The more these tools improve the How of coding, the more we see that we're behind the curve on improving the What, Why, and When. If you've been on a project that seemed vague, adrift, and endless, this talk can help. Make your projects run SMART.
Chris OBrien - Azure DevOps for managing workChris O'Brien
A presentation I gave at ESPC 2019 (the European SharePoint, Office 365 and Azure Conference) about Azure DevOps for managing both development and support work. The focus is on Azure DevOps boards and task management, but covers some CI/CD aspects too.
Tired of doing upfront test script creation in your testing efforts? Feeling bad for demotivating your testers? Want something to replace this sickening approach to software testing? This presentation outlines why test scripts are not useful, and how test ideas are the new way forward to better testing. Coverage, traceability, reporting, automation and skills are all covered. Take a quick look and see if you can see there is another way to do software testing that is actually pure common sense.
Agile Methodologies And Extreme ProgrammingUtkarsh Khare
The document discusses Agile development and Extreme Programming (XP). It provides an overview of 12 key practices of XP, including planning games, small releases, test-driven development, pair programming, collective ownership, continuous integration and 40-hour work weeks. It also discusses how XP aims to solve software engineering problems through intensive teamwork, handling changes and staff turnover, and involving customers.
Introducing Systems Analysis Design Developmentbsadd
This document introduces systems analysis, design, and development concepts. It uses a hypothetical example of developing an accounting software to illustrate key steps in the software development life cycle, including requirements analysis, modular design, documentation, version control, project management tools, and an emphasis on standards and best practices to facilitate collaboration and maintenance of the project. The overall process described is one of analyzing requirements, designing the system architecture and individual components, developing the software through teamwork while testing units of code, and evolving the software by returning to analysis when requirements change.
Existing methods for refactoring legacy code are either unsafe, or slow and require a lot of rare skills. I'm proposing a new method composed of three steps: refactor to pure functions, write tests for the pure functions, and refactor the pure functions to classes or something else. I believe that with a few mechanical steps a trained developer can safely refactor legacy code faster using this method.
The document discusses the author's experience with optional types in software design. It describes the author's shifting views on types over their career from enthusiast to professional to advocate for optional types. The author details how optional types can lead to cleaner, smaller code that is easier to change and requires fewer tests. Deep questions are also posed about the cognitive costs of abstractions, whether strong typing enables strong coupling, and how important names and contracts are in minimalist design. The conclusion is that minimalism exerts positive pressure on design through smaller code, better names, clear responsibilities and contracts, and clear tests.
A talk from CppEurope 2019 about functional programming in C++.
It talks about lambdas, immutability, operations with functions (partial application, currying, functional composition), shows an example and ends with a procedure for refactoring legacy code.
This document discusses ways to raise the bar of software development by combining it with other disciplines. It proposes 6 intersections between software design and other fields: 1) Software Design and UX, 2) Other design disciplines, 3) Materials Science, 4) Math, 5) Engineering principles of built-in self-testing, and 6) Reaching out to scientists. It argues that considering ideas from other domains could improve software design and help address challenges like dependencies in legacy code. The document also suggests ways to fundamentally change development by precisely defining requirements and generating code from them.
What can we learn from other design disciplines? How do they learn design? What can we copy from them?
This is a challenge for software developers to start thinking as code designers, as people who use code as a material to prototype solutions to problems.
What is good software design? Why does it matter?
In this keynote, I addressed this complex problem. Going from the history of programming, through analogies with other design disciplines, ending with conclusions on what is good software design, and how to become a better designer.
Slides for a workshop on agile technical leadership.
Agile teams are complex adaptive systems. In order to obtain a certain level of consistency, required when you want effective teams, teams have to set constraints on themselves and to make strategic decisions. This workshop explores some of the constraints and the difficulties of making strategic technical decisions.
One of the difficulties of developers starting to apply Test Driven Development (TDD) is letting go of preconceived notions of design and allowing themselves to evolve it. I have successfully used TDD As If You Meant It as a way of showcasing how design grows when doing TDD. TDD As If You Meant It is a set of constraints created by Keith Braithwaite that forces developers to let go of their set blueprints and allow the design to evolve. I've noticed in code retreats and dojos that the technique is very difficult to get right. In this session, I will explain the core technique, the value of the technique and what I've learned by applying it and by helping others applying it.
How to identify, when to remove and how to remove a common pattern in code: duplication that can be refactored towards loops and more complex data structures. Also with code examples.
The document discusses removing structural duplication from code. It defines structural duplication as similar code structures that repeat even if the internal actions differ. Examples given include conditional statements, exception handling, and views. The risks of duplication include increased size and unintended changes. The document provides steps to remove duplication such as separating structure from actions, extracting data models, and using loops to consolidate duplicated code. Both advantages like improved separation of concerns and disadvantages like increased rigidity are discussed.
This document discusses continuous delivery and provides steps to achieve it. Continuous delivery aims to provide fast, high quality feedback at multiple levels through the development process. It recommends having automated source control, builds, testing, deployment, monitoring and self-healing systems. The key steps are to have automated builds that pass all tests with each change, to measure and improve code quality, to implement automated validation of both code and features through tests, and to deploy and monitor applications automatically to catch any issues. Containers can help developers deploy applications for testing more easily. The overall goal is to establish a pipeline that allows for frequent, low-risk deployments.
This document discusses why developers should use Docker containers. It notes that Docker can help solve problems with reproducibility across environments by packaging applications and dependencies into self-contained units. An example is provided of a Dockerfile for a Java Spark application that defines what is needed to build and run the application in a container. The document encourages asking questions and experimenting with Docker to take advantage of its benefits like ease of use, large community support, and speed.
As a programmer, you are wondering what it takes to grow your career in a fast-changing environment. This talk is about a path for your career growth.
As a manager you are wondering how you can optimize your software development teams. This talk is about a model to use for a rough evaluation and improvement of your teams.
As a business owner, CEO or CTO, your primary request for development teams is to quickly add features. This talk is about a model for optimizing implementation time.
The pyramid of programming skillsets is a model based on the usefulness of programming skills when changing code fast is the most important business objective. Let’s explore five skillset levels I identified when working with teams of programmers around Europe. We will discuss each level and how to move from one level to another.
We've been discussing software craftsmanship for years. But does it match the realities of a business? How?
This is a story about applying the ideas and practices of software craftsmanship for a real project in a difficult context. The conclusion? It helped us, it might help you as well.
How can you advance your career as a software developer? How can you assess your team as a team leader / technical lead / manager?
I created a simple model to answer these questions based upon the most common need in modern software applications: the need to add features fast.
All models are wrong, but some are useful. I found this model useful and I hope you will too.
The document summarizes 10 practices for staying focused as presented by Alexandru Bolboaca. The practices include value stream mapping to visualize workflow, using visual management boards to track progress, removing blockages, dealing with bottlenecks, ensuring adequate resources, maintaining staff flexibility, holding effective meetings, limiting interruptions, planning team learning, and improving overall workflow flow. The talk encourages focusing efforts to clarify vision, minimize distractions, and eliminate anything not adding value in order to better deliver products and services.
An introduction to Kanban I presented with Flavius Stef at the Bucharest Agile Meetup Group in February 2014. See the event details on http://www.meetup.com/The-Bucharest-Agile-Software-Meetup-Group/events/146222892/. See http://mozaicworks.com for articles and events about Kanban and agile
This talk answers questions asked about unit testing by attendees at ALE 2013.
It was created in two hours, starting from an open space session where we gathered the questions.
Incremental design means implementing solutions one usage example at a time by splitting problems into smaller subproblems and defining behaviors through examples. The incremental design process involves splitting problems to find increments, identifying behaviors through examples, implementing examples one by one, and refactoring the solution by minimizing similarities and simplifying. An example is discussed to illustrate applying test-driven development and behavior-driven development principles through proof-based design and thinking about the problem before the solution.
Sami provided a beginner-friendly introduction to Amazon Web Services (AWS), covering essential terms, products, and services for cloud deployment. Participants explored AWS' latest Gen AI offerings, making it accessible for those starting their cloud journey or integrating AI into coding practices.
AI Chatbot Development – A Comprehensive Guide .pdfayushiqss
Discover how generative AI is transforming IT development in this blog. Learn how using AI software development, artificial intelligence tools, and generative AI tools can lead to smarter, faster, and more efficient software creation. Explore real-world applications and see how these technologies are driving innovation and cutting costs in IT development.
Explore the rapid development journey of TryBoxLang, completed in just 48 hours. This session delves into the innovative process behind creating TryBoxLang, a platform designed to showcase the capabilities of BoxLang by Ortus Solutions. Discover the challenges, strategies, and outcomes of this accelerated development effort, highlighting how TryBoxLang provides a practical introduction to BoxLang's features and benefits.
Ansys Mechanical enables you to solve complex structural engineering problems and make better, faster design decisions. With the finite element analysis (FEA) solvers available in the suite, you can customize and automate solutions for your structural mechanics problems and parameterize them to analyze multiple design scenarios. Ansys Mechanical is a dynamic tool that has a complete range of analysis tools.
A captivating AI chatbot PowerPoint presentation is made with a striking backdrop in order to attract a wider audience. Select this template featuring several AI chatbot visuals to boost audience engagement and spontaneity. With the aid of this multi-colored template, you may make a compelling presentation and get extra bonuses. To easily elucidate your ideas, choose a typeface with vibrant colors. You can include your data regarding utilizing the chatbot methodology to the remaining half of the template.
4. From a Team That Brought You
●
Code retreats in multiple languages -
http://coderetreat.org/history
●
Brutal Refactoring Game
●
Taking Baby Steps
●
Teddy Bear Pairing
●
I TAKE Unconference
●
And now usable software design
http://mozaicworks.com
14. Jacques Carelman
Artist, creator of “The Catalogue of Impossible Objects” in the 60s
http://www.patakosmos.com/wp-content/uploads/2013/09/RDA00147250.jpg
15. Coffee pot for masochists
Catalogue of Impossible Objects by Jacques Carelman
http://impossibleobjects.com/catalogue/coffeepot-for-masochists.html
16. Absorbent Bottle
Catalogue of Impossible Objects by Jacques Carelman
http://impossibleobjects.com/catalogue/absorbent-bottle.html
17. Siamese Hammers
Catalogue of Impossible Objects by Jacques Carelman
http://impossibleobjects.com/catalogue/siamese-hammers.html
19. Donald A. Norman
Author of “The Design of Everyday Things”
http://www.jnd.org/NNg-Photographs/Photo1.jpg
“It is the duty of
machines and those
who design them to
understand people. It
is not our duty to
understand the
arbitrary, meaningless
dictates of machines.”
20. User Centric Design Process by UXPA
Revolution started by Donald A. Norman's book
http://uxmastery.com/what-does-a-user-centred-design-process-look-like/
21. Any design has a user.
Who is the user of
software design?
Can't be the end user.
Then: the developer
=> Developer-centric
software design? DX?
How about “Usable
Software Design”?
22. So how to apply UX techniques to
software design?
●
Personas
●
User journey for developer
●
Quality attributes
●
Usability testing
●
Specific practices
24. Developer Persona For Your Team
●
Kernel Developer
●
Java Enterprise Developer
●
Rails Developer
●
C/C++ Embedded Developer
●
Android Developer
●
Front-end Javascript + html + CSS developer
●
Etc.
Each persona
has different
needs.
Usability
depends on the
user!
25. Example of Team Agreement
Usable Software Design means to us that:
1. It is written for developers to read
2. It is easy to find where to modify the code
3. Any modification has a minimal ripple-effect
4. It is easy AND fast to validate that we did the right thing
5. We don’t have to do similar modifications in several places
Usable Software Design – A Federating Concept
by Johan Martinsson
26. Next Step: Practices
“It is written for developers to read”
=> coding guidelines, clean code etc.
“It is easy to find where to modify the code”
=> navigability, consistency etc.
“Any modification has a minimal ripple effect”
=> follow Open Closed Principle, Single Responsibility Principle etc.
28. You Are The User: Changing Code
●
Figure out what you need to change
●
Navigate there
●
Read the code, tests, documentation, comments
●
Write/change code, write/change tests
●
Refactor
●
Build
●
Validate
●
Integrate
29. Figure Out What To Change
Static structure
{},
Understand
runtime behavior
33. Is Your Design Easy to Navigate?
●
What module / namespace to look in?
– See previous examples
●
How is that thing named?
– Should be Consistent, Memorable, Precise
●
How deep is the inheritance tree?
38. What is Usable Software Design?
Usable Software Design is
any code structure that exhibits
design qualities similar to usability
39. 5 Design Qualities of Usability
1. Learnability
2. Efficiency
3. Memorability
4. Errors
5. Satisfaction
http://www.nngroup.com/articles/usability-101-introduction-to-usability/
How easy it is to accomplish basic tasks the first time
you're using the design?
How quickly can you perform a task once you've
learned the design?
When you go back to the design after a period of not
using it, how easy is to become efficient again?
How many errors do you make, how severe are they
and how can you recover from them?
How pleasant it is to use the design?
40. 1. Learnability
How easy is it for users to accomplish
basic tasks the first time they encounter
the design?
41. Hints: Design For Learnability
Code structure that shows what the application does
Consistency
Minimal Surprise
Use Clearly Defined Modules With Clear APIs
Readability / Clean Code
Navigability
Add Usage examples – tests / comments etc
42. Test Learnability
Measure how long it takes for developers outside
your team to understand the purpose of a class
with as little help as possible.
44. Hints: Design For Efficiency
Use code constructs the whole team understands
Consistency
Fast Validation
45. Test Efficiency
Retro question: “what slowed you down in the past
two weeks?”
Measure how long it takes for developers to finish
typical tasks (not simple, but typical)
46. 3. Memorability
When you go back to the design after a
period of not using it, how easy is to
become efficient again?
52. Test Mistake-Proofing
How many bugs do we have?
What is the main cause of the bugs?
(remember, it's typically in the design)
How can we change the design to avoid
it?
57. How To Do Usability Testing
●
Pick a few common tasks
●
Ask a developer who is not part of the team but
knows the technology to do them
●
Gather the feedback
●
Define next improvement actions
59. I forgot to mention
●
You are not allowed to start the application, only
navigate through code
60. Results
●
First two tasks were too vague
– Create new event, create new user => write a new
feature? Create a domain entity?
– The feature existed, I was hinting at just creating a
domain entity and saving it from the code (no UI)
– It showed an inconsistency in design
●
Task 3 “Explain how an event is created in the
application” took less than 5'
61. ●
Task 4 “Validation for event creation” took less than 5', but it was
incomplete
– Claudia missed the client-side validation because...
– It was using custom tags extracted in a plugin that...
– Required to run “grails refresh-dependencies” but...
– It wasn't compiling because …
– It was using a library that …
– Needed compilation and publish to local maven
●
Improvement:
– Write a script “installDev” that installs everything needed for a new dev
63. ●
Task 6 “Reset password flow”
– Stopped after 15'
– Got around the middle of the flow
●
Conclusion
– Difficult to follow a more complex flow through an
application
– Need some way to provide this information fast (work
in progress)
64. Open Questions
●
What was your general impression of the design?
– “very nice, easy to understand”
●
What helped you understand?
– “the names & the structure”
●
What prevented you from understanding the
reset password flow?
– “difficult to follow”
65. Usability Tests - Conclusions
●
Usability tests are very useful for improving
productivity
●
Every time you take 1' more to understand the
code, you are not implementing a new feature
●
(If you finish a feature faster, you have more time
to read Quora :D)
68. Design Elements – Example from
eventrix.co
●
Controller
●
Command Object
●
Application Service
●
Database Service (Command)
●
Database Query
●
View Model
74. View Model
Responsibilities
●
Transform GORM
entities into maps
ready for rendering
●
! Limit the data
returned to the view
●
! Separate as much as
possible
Collaborators
●
Domain Model
classes
How To Test:
Unit Tests
75. Design Elements Are Not Everything
●
We discovered some more – e.g. multiple steps
flow
●
Utility classes
76. But they are ~90% of the code
●
Typical use cases:
– Request to create / update / delete
something: controller → command object →
database command → view model →
controller render
– Request to read something: controller →
application service / db query → view model
→ controller render
78. What To Tell Managers
Usable Software Design has the potential to bring four
economical benefits:
●
Faster integration of new developers in the team
(learnability)
●
Faster time to implement typical (not simple) tasks
(efficiency)
●
Making less mistakes (mistake-proofing)
●
Feeling more motivated (satisfaction)
79. Recap
●
The developer is the user of software design
●
Usable software design means code structure that exhibits the
qualities of usability: Learnability, Efficiency, Memorability, Error
Treatment and Satisfaction
●
Define the personas of your team
●
Create a team agreement
●
Start applying practices that help the agreement
●
Run usability tests
●
Identify design elements from your code to increase consistency
●
This is just the beginning
81. Tell me about your experiences
alex.bolboaca
@mozaicworks.com
@alexboly
mozaicworks.com/blog
alexbolboaca.ro
https://www.linkedin.com/in/
alexandrubolboaca/
82. Buy my book!
Special price for you:
https://leanpub.com/usablesoftwaredesign/c/thank-you-java-day-istanbul
Pay as little as for two Turkish Pizzas