Clare Sudbery
Independent technical coach
Actions
Clare Sudbery is an independent technical coach with over 20 years of software engineering experience. She specialises in TDD, refactoring, continuous integration and other eXtreme Programming (XP) practices.
Clare taught the Coding Black Females’ Return to Tech programme and co-ran Made Tech’s academy – coaching inexperienced engineers to learn on the job. She has a passion for helping under-represented groups to flourish in tech.
Clare hosted Season One of the acclaimed Making Tech Better podcast and publishes content on Medium (“A Woman in Technology”) and her own site (“In Simple Terms”). She is the author of the Stupidity Manifesto, has written about trunk-based development and refactoring for O’Reilly and for Martin Fowler’s site, and regularly presents workshops and keynotes at events all over the world.
Ensemble Working: The ultimate in collaboration (TALK)
When teams work well together, this can have a considerable impact on the quality of the software they deliver. But how can we help this to happen? Ensemble working – aka “mob programming” - is a powerful technique where, as Woody Zuill puts it, “All the brilliant minds [are] working together on the same thing, at the same time, in the same space, and at the same computer.”
Ensemble work maximises learning and collaboration, obliterates context switching and is particularly useful when onboarding new team members or embarking on a new project. Some teams work like this all the time, others only as the need arises. Like most powerful techniques, it’s a skill you need to learn. There are many things you can do to enhance its effectivity, and until you’ve experienced a well performing ensemble you might struggle to understand just how much impact it can have.
This talk examines the benefits in detail. Clare explains how she teaches the technique to new teams, and describes why it is her approach of choice in many different situations.
Takeaways
* Why ensemble working is such a powerful technique
* How to convince stakeholders who worry about budgets
* How to introduce ensemble working to new people
* How to maximise the effectiveness of an ensemble
Practical Refactoring Techniques
Are you working with code that needs improvement? Do you have a legacy code base which was not developed by your current team but still needs to be maintained and extended? Would you like to spruce up the code you’ve written yourself? Would you like to achieve all of this in a low-risk, low-impact way that can be achieved without disrupting ongoing work?
In this workshop you will get hands-on knowledge and experience of the following key practical techniques to up your refactoring game:
• Identifying code smells
• Making the most of the refactoring tools offered by your IDE (all examples will be .Net code in Visual Studio and Rider)
• Approval testing to safely refactor legacy code
• “Lift up conditional” – a powerful refactoring technique
Demonstrations will all be in C# using .Net Core, which means they will work in Linux, on a Mac or on a Windows operating system. You can do worked examples in a language of your choice. You will need coding experience. A Test-Driven approach will be used (although people are often surprised at how few new tests you need to write when refactoring).
Let’s Stop Making Each Other Feel Stupid
We work in an industry where we have to prove how much we know. And yet, there are a million different paths through software development. On a day-to-day level we have to specialise on one task at a time. The skills we don’t need now are necessarily forgotten, or delegated to someone else. And that’s fine.
Instead of judging people for their ignorance, let’s help them to feel excited about all the new things they’ll discover. Instead of saying “How come you don’t know that?” let’s say “Fantastic! Lucky you. You get to learn something. What can I do to help?”
Continuous Integration – That’s not what they meant
Many teams are practising continuous integration, or at least that’s the language they use. There are other terms in use too, such as continuous delivery and continuous deployment. The exact distinction between these terms depends on who you ask. But the big question is, just how continuous is it really?
Trunk-based development (TBD) is a powerful yet under-used technique for tightening the user feedback loop, lowering risk and minimizing the gap between coding and deployment. It’s a major component of good deployment practice, and many argue that anything other than trunk-based development does not technically qualify as continuous integration. But many developers are either not sure what TBD is, or do not feel able to use it.
This talk digs into the detail and the benefits of trunk-based development, and gives practical advice on how to make good use of the technique.
Key takeaways:
• What trunk-based development actually means
• The connection between continuous integration and trunk-based development
• The key practices and skills needed to make trunk-based development work
• How to gradually move towards better continuous integration, even if trunk-based development is not your goal
Compassionate Refactoring
Most coders wish they were refactoring their code more than they are.
Many things stand in our way (or so we think): The obvious one is time, and the associated pressure from our stakeholders. This is a real problem, and in this talk I will discuss ways of addressing it.
But one constraint that isn't often discussed is a lack of compassion. This doesn't only come from others, it comes from ourselves. We don't forgive ourselves when we write bad code. We think it's all or nothing. We mutter about the trail of bad code left by our forbears and feel guilty about the bad code we leave behind ourselves.
Refactoring shouldn't be something that happens after the fact - it should be, and can be, part of every day development. But before we write good code we have to write bad code, and that's OK. As with most creative endeavours if you insist on making the first draft perfect you will never get anything out the door.
This talk is about kindness and forgiveness, and the paradox that the more you accept and handle bad code, the more likely it is that you will end up with good code.
Key takeaways:
• Refactoring is something that can be done continuously, in tiny steps
• Compassion makes refactoring easier and more likely
• Rewrites are often not refactoring
Making Learning Conscious: How and why to build a learning culture
Sooner or later, all software professionals realise that there is no such thing as knowing all the things. More than any other, our industry is in a constant state of change. The more you know, the more you realise how much you don’t know.
But the most effective professionals are not only aware that the learning never stops, they embrace the challenge and the necessity of continuous improvement. Similarly, the best organisations will also not only accept this truth but face it head on.
In this talk Clare will discuss why, and how, to keep your skills and knowledge up to date – and in the process allow your organisation to retain, attract and create the most talented and effective professionals. The aim is to consider how you can nudge yourselves and your colleagues to a state of childlike fearlessness where learning is fun; is embedded in everything you do; and applies to all team members regardless of experience.
Key takeaways:
• What is a learning culture?
• Why is it so important?
• How can you create a learning culture?
• How will it improve your organisation?
Agile meets Architecture 2023 Sessionize Event
Clare Sudbery
Independent technical coach
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top