A code review is basically a technical discussion which should lead to improvements in the code and/or sharing
knowledge in a team. As with any conversation, it should have substance and form.
What’s involved in a good code review? What kind of problems do we want to spot and address? Trisha Gee will talk
about things a reviewer may consider when looking at changes: what potential issues to look for; why certain
patterns may be harmful; and, of course, what NOT to look at.
But when it comes to commenting on someone’s work, it may be hard to find the right words to convey a useful message
without offending the authors - after all, this is something that they worked hard on. Maria Khalusova will share
some observations, thoughts and practical tricks on how to give and receive feedback without turning a code review
into a battlefield.
Two years ago, we introduced Spock tests into the MongoDB Java driver. The decision could be considered controversial – the project used no external dependencies in production code, and was 100% Java. But there was a back door… with Gradle as the build system, there was a tiny excuse to use Groovy in the project, provided it wasn’t in the production code. That’s all the excuse we needed to start using Spock for unit and, later, integration tests.
Groovy has a lot of advantages as a testing language, and with Spock’s mocking, stubbing, and data driven testing features, it might seem as if this is the perfect way to write tests. In this session, Trisha will cover some of the features that make Spock (and Groovy) compelling for writing tests. But in the interests of fairness, she’ll also discuss some of the downsides, and the times when Java was chosen instead.
Presentation given at GOTO Chicago that looks at why we don't like to write tests and one approach to improving automated tests that was taken by the MongoDB Java Driver team.
A code review is basically a technical discussion which should lead to improvements in the code and/or sharing
knowledge in a team. As with any conversation, it should have substance and form.
What’s involved in a good code review? What kind of problems do we want to spot and address? Trisha Gee will talk
about things a reviewer may consider when looking at changes: what potential issues to look for; why certain
patterns may be harmful; and, of course, what NOT to look at.
But when it comes to commenting on someone’s work, it may be hard to find the right words to convey a useful message
without offending the authors - after all, this is something that they worked hard on. Maria Khalusova will share
some observations, thoughts and practical tricks on how to give and receive feedback without turning a code review
into a battlefield.
Two years ago, we introduced Spock tests into the MongoDB Java driver. The decision could be considered controversial – the project used no external dependencies in production code, and was 100% Java. But there was a back door… with Gradle as the build system, there was a tiny excuse to use Groovy in the project, provided it wasn’t in the production code. That’s all the excuse we needed to start using Spock for unit and, later, integration tests.
Groovy has a lot of advantages as a testing language, and with Spock’s mocking, stubbing, and data driven testing features, it might seem as if this is the perfect way to write tests. In this session, Trisha will cover some of the features that make Spock (and Groovy) compelling for writing tests. But in the interests of fairness, she’ll also discuss some of the downsides, and the times when Java was chosen instead.
Presentation given at GOTO Chicago that looks at why we don't like to write tests and one approach to improving automated tests that was taken by the MongoDB Java Driver team.
San Francisco Software Craftsmanship Meetup
Test Driven Developers Bay Area Meetup
TDD Flow: The Mantra in Action” is a talk + hands-on about the mantra of TDD and its core patterns. Here are some questions for this talk: What is TDD? How to write a good test that fails? How to write code enough to make the test pass? How to remove duplication? How to refactor code? How to create clean code? Is TDD about testing or design? How small should a test be? Should I only write unit tests? Should I estimate TDD? How to use TDD with other agile methods like Scrum, Kanban or BDD? And finally, how to flow in TDD?
TDD vs. ATDD - What, Why, Which, When & WhereDaniel Davis
This is a slide deck for a discussion about Test Driven Development (TDD) and Acceptance Test Driven Development (ATDD) and starting to explore the differences between them. Get some insight into why we use them and the advantages and disadvantages of both, as well as, get a better understanding of which should be used where and when. By the end of the session you should be well along the path to TDD vs. ATDD enlightenment.
How do you go about implementing clean code in a medium R&D organization? As tech lead of scrum team, I describe the process implemented in AT&T Israel as case study
Test-driven development is generally regarded as a good move: it should result in simple decoupled design, your tests tend to cover behaviour not methods, and far fewer bugs. However, just getting unit tests in on a real, commercial project is hard - switching to TDD is even harder. Often you can start a project with good intentions and coverage, then the deadline looms and the tests go out then the hacks come in. So, instead of beating ourselves up about not being perfect let's look at an interative approach to adopting TDD principles. We'll look at tactics for selling TDD to your client, boss and colleagues. This talk will also cover methods for making TDD easier for you by showing you what tools you can use to integrate it into your development environment. In the project itself, we'll examine how we can make small but permanent steps towards full TDD, without losing that progress when deadlines hit. We'll also cover a few methods for learning on your own time and how the whole process can actually be made quite enjoyable.
Part of the internal Codeweavers Development series from our Academy.
Writing Tests are a fundamental part of our development workflow but it's not easy to write them well. This talk dives into this and throws a few spanners in the works from what people traditionally think.
Unit testing is an essential part of software design and development. But somehow it is considered as testing and its value is not known to majority of the software teams. This presentation tries to show the value of unit testing.
Pair programming and introduction to TDDArati Joshi
These are slides used in a workshop on TDD. Slides explain more about different types of pair programming techniques when to use each, what is TDD and how to start thinking about TDD as mindset change.
San Francisco Software Craftsmanship Meetup
Test Driven Developers Bay Area Meetup
TDD Flow: The Mantra in Action” is a talk + hands-on about the mantra of TDD and its core patterns. Here are some questions for this talk: What is TDD? How to write a good test that fails? How to write code enough to make the test pass? How to remove duplication? How to refactor code? How to create clean code? Is TDD about testing or design? How small should a test be? Should I only write unit tests? Should I estimate TDD? How to use TDD with other agile methods like Scrum, Kanban or BDD? And finally, how to flow in TDD?
TDD vs. ATDD - What, Why, Which, When & WhereDaniel Davis
This is a slide deck for a discussion about Test Driven Development (TDD) and Acceptance Test Driven Development (ATDD) and starting to explore the differences between them. Get some insight into why we use them and the advantages and disadvantages of both, as well as, get a better understanding of which should be used where and when. By the end of the session you should be well along the path to TDD vs. ATDD enlightenment.
How do you go about implementing clean code in a medium R&D organization? As tech lead of scrum team, I describe the process implemented in AT&T Israel as case study
Test-driven development is generally regarded as a good move: it should result in simple decoupled design, your tests tend to cover behaviour not methods, and far fewer bugs. However, just getting unit tests in on a real, commercial project is hard - switching to TDD is even harder. Often you can start a project with good intentions and coverage, then the deadline looms and the tests go out then the hacks come in. So, instead of beating ourselves up about not being perfect let's look at an interative approach to adopting TDD principles. We'll look at tactics for selling TDD to your client, boss and colleagues. This talk will also cover methods for making TDD easier for you by showing you what tools you can use to integrate it into your development environment. In the project itself, we'll examine how we can make small but permanent steps towards full TDD, without losing that progress when deadlines hit. We'll also cover a few methods for learning on your own time and how the whole process can actually be made quite enjoyable.
Part of the internal Codeweavers Development series from our Academy.
Writing Tests are a fundamental part of our development workflow but it's not easy to write them well. This talk dives into this and throws a few spanners in the works from what people traditionally think.
Unit testing is an essential part of software design and development. But somehow it is considered as testing and its value is not known to majority of the software teams. This presentation tries to show the value of unit testing.
Pair programming and introduction to TDDArati Joshi
These are slides used in a workshop on TDD. Slides explain more about different types of pair programming techniques when to use each, what is TDD and how to start thinking about TDD as mindset change.
Log Classification in the Hardwood Timber Industry: Method and Value AnalysisAlvaro Gil
Industries with variable inputs, such as the forest product industry (FPI), the mining industry or the recycling industry, must cope with material uncertainty, which affects their ability to predict output yields. To deal with this, one can either reduce uncertainty at the source, or plan operations taking uncertainty into account. In the FPI, the first approach is generally used. For instance, the softwood lumber industry has adopted sophisticated transformation technologies that adapt sawing patterns to the log characteristic using scanners technology to acquire accurate information about work-in-process status. Another approach to reduce uncertainty is input material classification. Specific characteristics can be measured to classify input material and therefore reduce uncertainty within each class. However, whether the process involves logs, mining ores or recycled papers, material classification has a value and a cost according to how detailed it is performed. This research first proposes a method based on classification tree analysis to classify hardwood logs. Next, using agent-based simulation, it analyses the value of different classification strategies, from detailed, to no classification at all. Results show in the context of the hardwood lumber industry that the benefit of detailed classification is offset by its cost, while a relatively simple classification dramatically improves output yield.
Séminaire e-Xpert Solutions : Log Management
La centralisation des logs, 1ère étape avant la corrélation
Définition d’un log
Pourquoi les logs sont-ils si importants ?
Définition du terme Log Management
Log Management / SEM, quelles différences ?
Evolutions / Tendances
Les fonctionnalités premières d’un bon Log Management
Conclusion
Artificial intelligence (AI) is everywhere, promising self-driving cars, medical breakthroughs, and new ways of working. But how do you separate hype from reality? How can your company apply AI to solve real business problems?
Here’s what AI learnings your business should keep in mind for 2017.
Test Driven Development (TDD) is a core practice in the SDLC, especially ones that run using the agile mindset and leverage the practices of eXtreme programming. Since its inception and rediscovery by Kent beck in the late 1990s, it has gained popularity among many software development teams. However, like any popular software development practices, teams lose interest in TDD overtime and drop the practice all together. The main reason behind this is practicing it "the wrong way".
In this session, I present 7 anti-patterns that can ruin the TDD experience of a software development team. I also present how to counter these anti-patterns to fully leverage the benefits of TDD.
Becoming a Software Craftsman takes a lot of practice. Using Code Katas in Coding Dojos is an excellent way to get that practice in a low stress fun way. Discover how to do that.
Have you heard of TDD? Are you interested or familiar with this practice but have never been able to understand it?
Join this session to see the benefits of Test-Driven Development (TDD), understand how it works and its benefits. In a more detailed approach, we will see this way of developing software, where our code is always built guided by tests.
We will go over some history about TDD, which is the main process we must follow when we work with this mechanic and the rules that surround it. We will also list the main advantages and disadvantages that most developers who practice TDD find and whether the arguments in favour add up to more than those that subtract. Finally, we will review some good habits and practices when applying TDD and see how to do it step by step with an example of a "live" coding session with Java.
At the end of the session, I hope that you will have a wider understanding of what TDD is, what advantages it brings, why it is interesting to master it and also that you will take with you some tricks and good practices to be able to apply them in your day-to-day life when writing code
===
Presentation (revisited & updated) shared at JDD 2022:
https://jdd.org.pl/lecture_2022/#id=78434
TDD - Seriously, try it! - Trójmiasto Java User Group (17th May '23)ssusercaf6c1
Have you heard of TDD? Are you interested or familiar with this practice but have never been able to understand it?
Join this session to see the benefits of Test-Driven Development (TDD), understand how it works and its benefits. In a more detailed approach, we will see this way of developing software, where our code is always built guided by tests.
We will go over some history about TDD, which is the main process we must follow when we work with this mechanic and the rules that surround it. We will also list the main advantages and disadvantages that most developers who practice TDD find and whether the arguments in favour add up to more than those that subtract. Finally, we will review some good habits and practices when applying TDD and see how to do it step by step with an example of a "live" coding session with Java.
At the end of the session, I hope that you will have a wider understanding of what TDD is, what advantages it brings, why it is interesting to master it and also that you will take with you some tricks and good practices to be able to apply them in your day-to-day life when writing code
---
Presentation shared at Trójmiasto Java User Group
Public group 17th of May '23
TDD - Seriously, try it! - Trjjmiasto JUG (17th May '23)Nacho Cougil
Have you heard of TDD? Are you interested or familiar with this practice but have never been able to understand it?
Join this session to see the benefits of Test-Driven Development (TDD), understand how it works and its benefits. In a more detailed approach, we will see this way of developing software, where our code is always built guided by tests.
We will go over some history about TDD, which is the main process we must follow when we work with this mechanic and the rules that surround it. We will also list the main advantages and disadvantages that most developers who practice TDD find and whether the arguments in favour add up to more than those that subtract. Finally, we will review some good habits and practices when applying TDD and see how to do it step by step with an example of a "live" coding session with Java.
At the end of the session, I hope that you will have a wider understanding of what TDD is, what advantages it brings, why it is interesting to master it and also that you will take with you some tricks and good practices to be able to apply them in your day-to-day life when writing code
---
Presentation shared at Trójmiasto Java User Group (17th May '23)
Creating change from within - Agile Practitioners 2012Dror Helper
Faced with management that do not care about "being agile" what can a single developer do? Quite a lot!
Every developer has the power to improve the organization he works in in small iterative steps – and I can show you how.
If you want to make the change and don't know where to start – look no further, in this session I'll share my experience and show a few tips and tricks I learnt. As well as discuss the do and don'ts that can make all the.
- How to be agile developer in a waterfall company.
- Influencing people without formal authority.
- Using the right practices that makes the difference
- How to avoid alienating people
- Discovering your allies
- Know when to fight and when to "retreat" and cut your losses
- Making a change without disrupting the daily routine
- What being an agile evangelist is all about
Join this session to see the benefits of Test-Driven Development (TDD), and understand how it works and its benefits. In a more detailed approach, we will see this way of developing software, where our code is always built guided by tests. We will go over some history about TDD and list the main advantages and disadvantages that most developers who practice it find and whether the arguments in favour add up to more than those that subtract. Finally, we will review some good habits and practices when applying TDD by seeing how to do it step by step with an example of a "live" coding session with Java. At the end of the session, you will have a wider understanding of TDD and why it's interesting to master it. Also, you will take with you some tricks and good practices to be able to apply them in your day-to-day life when writing code.
---
Presentation shared at Bucharest Tech Week '23
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Generating a custom Ruby SDK for your web service or Rails API using Smithyg2nightmarescribd
Have you ever wanted a Ruby client API to communicate with your web service? Smithy is a protocol-agnostic language for defining services and SDKs. Smithy Ruby is an implementation of Smithy that generates a Ruby SDK using a Smithy model. In this talk, we will explore Smithy and Smithy Ruby to learn how to generate custom feature-rich SDKs that can communicate with any web service, such as a Rails JSON API.
Key Trends Shaping the Future of Infrastructure.pdfCheryl Hung
Keynote at DIGIT West Expo, Glasgow on 29 May 2024.
Cheryl Hung, ochery.com
Sr Director, Infrastructure Ecosystem, Arm.
The key trends across hardware, cloud and open-source; exploring how these areas are likely to mature and develop over the short and long-term, and then considering how organisations can position themselves to adapt and thrive.
FIDO Alliance Osaka Seminar: The WebAuthn API and Discoverable Credentials.pdf
TDD - Christchurch APN May 2012
1. Test Driven Development
Demonstrated
Alan Christensen @christensena
Tom Gutteridge @trgutteridge
A g ile P r o f e s s io n a ls N e t w o r k
C h r is t c h u r c h
Th a n k s to o u r s p o n s o r s …
11. Test Driven
Development
• It is a development technique
• Incremental (iterative) workflow
• Always write a failing test
first (red)
• Only write the minimum
code to pass the failing test
(green)
• Improve code while all tests
are passing (refactor) http://www.agileapps.co.uk/methodology/continuous.html
12. Not about testing #1
• Yes you do end up with a suite of tests
• But TDD is a development exercise
• my mindset is coding, not testing
• I will not be exhausting edge cases, etc
(at least initially)
13. Not about testing #2
• By practicing TDD
• I approach my code from the outside,
focusing on specifying behaviour
• I can focus on one thing at a time
• My resulting code is inherently designed
for testability
• I get fast feedback
14. Live coding exercise
• Coding Kata
• Wikipedia definition: “A code kata is an
exercise in programming which helps hone
your skills through practice and repetition”
15. TDD improves design
• Encourages separation of concerns/single
responsibility principle (SRP)
• Incremental, iterative: can lead to simpler
designs
• Reduces fear of refactoring, encouraging
improvements to design
• Alerts me to design smells
16. Tests as documentation
• Unit test code provides numerous working
examples of API usage
• Good unit test structure and naming can
act as a specification
• Tests as documentation always up to date
(or the tests are failing)
17. Objections to TDD
• It takes too much time
• Tests can make it harder to refactor, not
easier
• It’s just too hard with our legacy code or
un-mockable framework(s)
• Our test suite takes too long to run so we
don’t run it very often
18. Why is TDD Hard?
• Mindset seems unnatural at first
• Many frameworks/library components
make it difficult to verify behaviour
• Large monolithic blocks of legacy code are
hard to isolate
• Good design is not always obvious at first
• Forgetting to test first, not afterwards!
19. Make TDD easier
• Practice Red-Green-Refactor discipline on
simpler examples (e.g. katas) away from a
real code base
• Learn from each other (e.g. weekly brown
bag/dojo sessions), pair programming
• Learn good design, especially OO design
• Listen to your tests! If it’s getting hard
going, consider refactoring your code
• Take it seriously!
20. Tips: Untestable
Frameworks
• Use adapter pattern to "broker" untestable
dependencies
• Adapters should be tailored to how they
are used by the app. Adapters do not need
to expose entire API, only what is needed
• Decouple logic from frameworks (e.g. use
MVC pattern)
21. Productivity with TDD
• It takes practice to become productive
• Test code should be taken seriously, not
treated as throwaway
• Keep duplication to a minimum but balance
this with readability
• Worst case: your design completely
changes resulting in rewrite. You have the
old tests as a reference (specs)
23. What is a unit?
• "smallest thing that makes sense" George
Dinwiddie
• Sometimes a method, sometimes a
collaboration of classes
24. Unit vs Integration
• Unit tests
• should be fast (fast feedback loop)
• should be focused
• when they fail, they usually point you to
where problem is
• rigorous within the component under
test
• one assert per test
25. Integration vs Unit
• Integration tests
• usually slow
• good for verifying unit tested
components connect together properly
• good for acceptance tests
• often easier to start with on a legacy
code base
26. Other Topics
• System Under Test isolation (mocks and
stubs)
• Real World Unit Testing (or how to deal
with existing test unfriendly code)
• Context specification (or how to write
expressive, DRY test suites)
• Tips and Tricks, avoiding anti-patterns
27. Links
• String Calculator kata exercise
http://osherove.com/tdd-kata-1/
• Bowling game kata step by step
(Powerpoint)
http://butunclebob.com/ArticleS.UncleBob.TheBow
