Pratique du Shadowing: What Software Architecture Should Look Like • Dave Farley • GOTO 2022 - Apprendre l'anglais à l'oral avec la vidéo

Choisissez un mode d'entraînement

Chaque mode ouvre une salle d'entraînement en plein écran.

210 phrases

Si les phrases sont trop courtes ou trop longues, cliquez sur Edit pour les ajuster.

Wikipedia defines software architecture as the functional structures of a software system and the discipline of creating such structures and systems.

Well you can kind of see what they mean

but it's a pretty dry definition and it raises as many questions as it really answers.

After all, what does fundamental mean anyway?

And for that matter, what does structure mean in this context too?

The last bit is really only saying architecture is produced by a disciplined approach to architecting things.

To be fair to Wikipedia, this is a difficult idea to nail down.

Even though I think that most of us would agree that it's an important one in some way.

So here is my take on software architecture.

What does it mean and what does it take to do a good job of it?

Hi, I'm Dave Farley of Continuous Delivery.

Welcome to my channel.

If you haven't been here before, please do hit subscribe.

And if you enjoy the content today, hit like as well.

My thinking on software development, design and architecture is deeply informed by what I think of as an engineering approach.

I describe this generally applicable approach in my new book, Modern Software Engineering.

It's doing rather well in the rankings on Amazon at the moment, and he's collecting some very nice reviews.

So do check it out.

There's a link to that in the description below too.

I think of myself as a software developer.

Probably more accurately these days, I'm a consultant first and a developer second.

But I also spent a considerable part of my career being called a software architect in one form or another.

I couldn't then and can't now tell you any significant difference in my focus between the times

when I was called a developer and the times when I was called an architect.

Ultimately, I think this is about design.

Maybe it's about design at different scales, but I confess that I'm rather skeptical of that.

The slippery nature of defining architecture as design on a bigger scale is that design in information systems is kind of fractal.

There are things that matter at all levels of detail

and there are tiny details that will invalidate grand assumptions

and there are grand assumptions that can prevent effective progress at the level of tiny detail.

A popular description of software architecture comes from Grady Booch who says architecture represents the significant design decisions

that shape a system where significance is measured by cost of change.

I don't disagree with this definition but I don't like it very much it implies

that these are the details

that we need to get right at the start to succeed it makes some sense

if we're looking retrospectively at a system

but it's a pretty poor guide to building one be omniscient for something this complex

that simply isn't going to happen for me there's only one approach to architecture that makes any sense at all.

It has to be an evolutionary process.

We will guide the design of our system by modifying the constraints that we apply to that design.

These constraints or rules of the road are what we think make sense at any given point.

These form an important aspect of our architecture.

We create a kind of tourist map of the system that we can use as a tool to guide design choices.

Here's the tourist map from one of my systems.

This map guides the evolution of the system in the direction of the outcomes that we aim to achieve.

If we're doing a good job we'll discover our inevitable mistakes and update our tourist map as our understanding deepens.

Let's try and walk into this problem a little bit more carefully.

One great definition of software architecture is it's the stuff that we wish we'd got right at the start of a project.

perhaps a little more helpfully it's the shared understanding

that the expert developers have of the system design both of

these definitions come from ralph johnson i'd add a couple of

words to the second it's a snapshot of the shared understanding

of the expert developers you hope it doesn't change too often

but you should expect it to change i think that in combination these definitions get something rather important right.

At the start of any project, we don't yet know the answers, but we still need to make some guesses about what may work in order to begin.

If we're going to be creating this system as part of a team, we need a way to discuss design ideas to communicate with each other about the system

and think about where different behaviours of the system will be handled.

Our tourist map will help a lot with these conversations.

Debating new features in front of the tourist map can we can explore the implications of our design choices

and maybe spot improvements or mistakes in the map.

I like Ralph Johnson's focus on the stuff we wish we

got right rather than a focus on the stuff we must get right.

We focus on the stuff that worry us.

I like it because we almost certainly won't get it right first time but it is important stuff.

That aligns very nicely with my thinking

and my approach to development in general really which is significantly focused on maintaining my freedom to get things wrong.

That probably sounds a bit weird but I want the freedom to make a mistake

and the ability to learn and recover from it.

For that we need the ability to contain the complexity and to manage it.

Fundamentally the architecture of our system is realized in the shapes that we make with our code.

All software has an architecture.

in some of them though it happened by accident in others it was worked on with great care

and grew to be something good good architecture allows us to

isolate one part of the problem from another this could be functional let's create services aligned with bounded context

so that they can change more independently of one another

or it could be in the jargon of architects non-functional let's shard the data in our system

so that it can scale linearly as demand rises

more formal approaches to architecture often discuss architectural measures of quality

this is the list from ISO I can see how talking about the illities of a system can help

but in reality I don't really buy into the idea of non-functional requirements very much

inside every non-functional requirement is a feature of the system that users care about If not, why are we doing it at all?

Even something as seemingly self-centered as making our code maintainable is

really about ensuring our ability to continue to deliver value to our users in the future.

These things, security, performance, scalability, testability, deployability, resilience, and so on,

are behaviors of our system as much as taking payment with a credit card.

We have to design the system to exhibit these behaviours.

If we are sensible, we will design our system to manage the complexity of these things by compartmentalising them from other behaviours where we can.

The reason that people get worried about these kinds of qualities of a system

and try to teach them somewhat differently is that they tend to have a broader impact than many features.

can't usually fix security or scalability or resilience in a single place in your system.

These are often referred to as cross-cutting concerns but that doesn't mean

that these things are architectural concerns and other things are not.

These are just behaviors that people often forget about while chasing other kinds of features.

Whether you call yourself an architect or not and and whether you work in a big team or alone, for any given piece of software,

you need to decide how it should behave.

And that means how you process credit cards or what color your buttons are, as well as is it okay to leak money to attackers

or fall over when there are more than three people using it.

This is our responsibility as software developers.

For some types of systems, some of these problems are genuinely difficult And it helps a lot when you have smart,

100

experienced people on the team who have seen ways to cope before.

101

But that doesn't mean that architecture is somebody else's problem.

102

Whether you are in your first day on the job or a grizzled veteran, your decisions may impact on the architecture of the system.

103

This is another of those slippery aspects of software.

104

There is very little distance between what looks like a small change and that small change having a massive impact.

105

In fact, the only things between that being true are luck

106

or a good working design and architecture that we understand and can use to guide our fine grained decisions.

107

So that gives us another step forward in understanding this complex concept a little better.

108

The architecture of our software is the collection of constraints

109

that we agree to adopt and maintain that will provide us some protection from making dumb mistakes.

110

My preference is to engage every developer, whatever their experience in architectural discussions,

111

allowing everyone to develop their own understanding of the architecture and to contribute to it as development proceeds.

112

Architect as a job description has seen a bit of a decline in recent years.

113

This is mostly in response to agile development's reaction against big upfront design.

114

The problem with this is, as Dave Thomas famously said, big upfront design is dumb, no upfront design is dumber.

115

So we need to start somewhere, but where?

116

The real answer is that you make a guess based on your understanding of the problem so far and your experience.

117

If you're any good at this kind of thing, you try to treat this guess as an experiment.

118

How could you show that your guess is wrong.

119

Try that.

120

Working incrementally, whether in fine-grained design or big picture architecture, is essential to doing a good job of anything complex.

121

There's a caveat to this, but as ever, you need to understand the trade-offs.

122

If the problem that you are solving is pretty common, then you could adopt a tried and tested architectural approach,

123

an off-the-peg architecture if you like.

124

This is a good idea as long as you understand the constraints and the fit of that architecture to your problem.

125

Because the other big problem with software architecture as an idea is that there's no one size fits all.

126

There's no such thing as a generically good architecture.

127

Rather it's a matter of whether a particular architecture fits the needs of the system.

128

one of the most successful widely applicable architectures was a layered

129

system backed up by a relational database something like this a ui some logic

130

and a database for systems with a moderate number of users

131

and relatively simple crud style features this was a very good choice i think

132

that one of the reasons it was a good choice though is quite informative i think a principal reason

133

that the clever but slow idea of transactions in relational databases took hold was

134

because it allowed programmers to write multi-user systems without worrying too much about the horrible complexity of concurrency.

135

If you open a transaction, read some data, change it, and write it out again, the database will block any other access to that data

136

while you're dealing with it and as long as

137

that as long as your transaction lasts it locks access to the data this was very good

138

if this architecture fit your problem it kept the programming model simple it's still good

139

if it fits your problem today and it fits quite a lot of problems quite well

140

however as the web grew in influence

141

and massive scale computing became more common having a relational database management system as a synchronization point to your data,

142

a source of truth, simply didn't scale.

143

So people started experimenting with other approaches.

144

I was once asked to consult on a huge project.

145

They had decided to use a NoSQL database as their primary data store,

146

which is fine, but they'd forgotten or didn't realize the importance of the protection

147

that transactions that they were more accustomed to had given them.

148

This NoSQL database wasn't transactional.

149

So data was shared by multiple processes and written to by multiple processes and the results were essentially random.

150

Whoever wrote last got to store their changes.

151

Everyone else would lose theirs and without any indication of the loss.

152

It made me feel a bit queasy just to think about this big system with all the data shared

153

and no protection or coordination between concurrent processes.

154

This was a problem of not really thinking about the architecture of the system but only the tools.

155

That's not the same thing.

156

A collection of tools alone doesn't make a software architecture.

157

This team had seen one of the big web companies develop

158

this great looking NoSQL database to help them scale up and it did that,

159

but only in the context of a whole raft of other choices and constraints that this team hadn't thought to apply.

160

There is another somewhat similar very common mistake that probably is a little closer to your own software.

161

Microservices were invented to decouple development.

162

They're intended to be independently deployable, freeing teams to work separately from other teams,

163

which means you don't get to test them together before you release.

164

If you are Netflix or Amazon, this is fantastic.

165

If you are a small development shop with a handful of developers, it's almost certainly overkill and so pretty inefficient.

166

And worse than that, most teams that I see that claim to practice microservice approach aren't.

167

They don't have independently deployable services, which means that they have to test them all together before they feel confident to release them.

168

This is in fact a distributed monolith, which is a rather complex choice, good for some things, but never simple.

169

I think that software is more complicated than we often think.

170

So the sensible thing is to approach it with a little bit more caution.

171

I don't mean that we should agonise for weeks or months before taking the first step, completely the opposite in fact,

172

but we should work on the assumption that our best guess so far is almost certainly wrong.

173

So architect our systems to allow us to recover when we learn more and find out where it's wrong.

174

This takes skill, certainly, but it is realistically the only sensible choice in my opinion.

175

Architecting a complex system is not something that someone in an ivory tower does at the start of a project.

176

It's also only partly intentional.

177

Like more fine-grained design decisions, it's an iterative incremental exercise in a kind of guided evolutionary process.

178

This is not terribly precise, and sometimes, even despite cleverness, expertise, and experience, people get things wrong.

179

That is, I am afraid, an inevitable consequence of dealing with something as tricky and complex as software.

180

A few years ago, a performance optimization strategy in Intel processors meant that encryption could be broken,

181

obviating all of the clever security architecture features in the web, cloud, on-premises systems, even mobile devices, and on pretty much every operating system.

182

That is a salutary lesson in how fragile architecture and design can be to tiny things.

183

a good way to approach this is to think about the things

184

that you are unsure of I was chatting to my friend Kevlin Henney a few days ago

185

and we were talking about design he said as soon as

186

someone says I don't know there's a seam in the design

187

that's quite a good way to think start the design of

188

your system with your best guesses based on what you know

189

so far and be on the look at for the things that you don't know or are unsure about.

190

You don't have to do a depth first exploration of these things.

191

In fact, you shouldn't.

192

But you do think about how to insulate the stuff that you do understand from the things that you don't.

193

Crude sketches in code of those things that you don't yet understand

194

and abstraction can act as placeholders while you make progress

195

and grow your understanding for the bits of the code that you do know.

196

Don't build world-class security into the first sketches of your system.

197

Don't take on the burden of making your system perfectly scalable from day one, but do design your system as best as you can imagine

198

so that you will be able to enhance security without undoing the progress

199

that you've already made and that you can take advantage of your great work

200

so far and allocate it differently so that it does scale up if that's a demand.

201

Insulate the parts of the system that you understand well from those that you don't yet.

202

These kinds of design approaches are at the heart of what I describe in my modern software engineering book.

203

Using the techniques to manage complexity, to give you a chance to go back and enhance or even correct architecture missteps when you discover them.

204

When we built our exchange at LMAX, we had three different fundamental attempts at the basic architecture of our system.

205

But because we'd taken an incremental approach to its design, only a small part of our effort was lost on each change.

206

My final piece of advice on software architecture is to aim to be intentionally a little bit vague about the detail.

207

Architecture should guide our decisions with constraints,

208

but in great architecture there are actually relatively few constraints but those that are there are pretty rigidly enforced.

209

Thank you very much for watching.

210

Thank you.

Télécharger l'application

Tout pour parler couramment

Prononciation IAChaque phrase notée

Phonétique (IPA)Maîtrisez chaque son

VocabulaireEnrichissez votre lexique

Jeu de vocabulaireApprenez en jouant

Scanner le QR

Download on theApp Store Get it onGoogle Play

FOR YOU

Vidéo recommandée

129 phrases

Vocabulaire et conseils d’expression pour cette leçon

Cette leçon d’expression orale de niveau C1 s’appuie sur la vidéo « What Software Architecture Should Look Like • Dave Farley • GOTO 2022 ». Les mots qui reviennent le plus souvent : architecture, design, software. Cette vidéo contient 210 phrases et 3001 mots à répéter en shadowing. La partie parlée dure 19:10. Le locuteur parle à un rythme naturel d’environ 157 mots par minute, proche d’une conversation courante. 83 % des mots font partie des 3 000 mots les plus courants en anglais ; le reste mérite d’être vu avant de commencer.

Vocabulaire clé de cette vidéo

Les 15 mots les plus avancés de la vidéo, avec leur prononciation et leur sens :

Mot	Prononciation	Sens
architect nom	/ˈɑɹ.kɪˌtɛkt/	architecte
constraint nom	/kənˈstɹeɪnt/	contrainte
architectural adjectif	/ˌɑɹkɪˈtɛkt͡ʃəɹəl/	architectural
complexity nom	/kəmˈplɛk.sɪ.ti/	complexité
relational adjectif		relationnel
sensible adjectif	/ˈsɛn.sɪ.bəl/	sensé, raisonnable
independently adverbe	/ˌɪndɪˈpɛndəntli/	indépendamment
assumption nom	/əˈsʌm(p).ʃ(ə)n/	assomption
insulate verbe	/ˈɪnsʊleɪt/	isoler
scalability nom	/ˌskeɪ.ləˈbɪl.ɪ.ti/	extensibilité
resilience nom	/ɹɪˈzɪl.ɪ.əns/	résilience
slippery adjectif	/ˈslɪpəɹi/	glissant
align verbe	/əˈlaɪn/	aligner
unsure adjectif		incertain
evolutionary adjectif	/ˌiː.vəˈluː.ʃən.ɛɹ.i/	évolutif, évolutionnaire

Les verbes à particule que vous entendrez

Mot	Sens
back up verbe	reculer
find out verbe	découvrir, savoir
go back verbe	rentrer, retourner

La grammaire de cette vidéo

Les structures que le locuteur utilise le plus, avec les mots exacts de la vidéo :

Structure	Dans la vidéo
Phrases conditionnelles if + proposition, will/would + verbe — une condition et son résultat	If we're doing a good job we'll discover · If we are sensible, we will design
Voix passive be + participe passé — l’accent est mis sur ce qui arrive, pas sur qui le fait	is produced · being called · was called
Present perfect have/has + participe passé — une action passée qui compte encore maintenant	haven't been · have seen · has seen
Propositions relatives who / which + proposition — une précision sur une personne ou une chose	really which is · services, which means · monolith, which is

Prononciation à surveiller

Le locuteur utilise 46 contractions et formes réduites, comme don't, doesn't, I'm. Prononcez-les sous leur forme courte, telles que vous les entendez.

Les sons « sh » et « zh »: assumption /əˈsʌm(p).ʃ(ə)n/, evolutionary /ˌiː.vəˈluː.ʃən.ɛɹ.i/, abstraction /æbˈstɹæk.ʃn̩/, inefficient /ˌɪn.ɪˈfɪʃ.ənt/, implication /ˌɪmpləˈkeɪʃən/
Mots longs — placez bien l’accent: architectural /ˌɑɹkɪˈtɛkt͡ʃəɹəl/, complexity /kəmˈplɛk.sɪ.ti/, independently /ˌɪndɪˈpɛndəntli/, scalability /ˌskeɪ.ləˈbɪl.ɪ.ti/, resilience /ɹɪˈzɪl.ɪ.əns/

Les sons difficiles pour les francophones :

/h/ — il se souffle, il n’est pas muet: enhance /ɪnˈhæns/, helpfully /ˈhɛlp.fəl.i/, behave /bɪˈheɪv/
/tʃ/ et /dʒ/ — à ne pas adoucir en « ch » et « j »: architectural /ˌɑɹkɪˈtɛkt͡ʃəɹəl/, sketch /ˈskɛt͡ʃ/, generically /dʒəˈnɛɹɪkli/, jargon /ˈdʒɑː.ɡən/, fragile /ˈfɹæd͡ʒəl/
/r/ anglais — langue recourbée, sans frotter la gorge: architect /ˈɑɹ.kɪˌtɛkt/, constraint /kənˈstɹeɪnt/, architectural /ˌɑɹkɪˈtɛkt͡ʃəɹəl/, upfront /ʌpˈfɹʌnt/, resilience /ɹɪˈzɪl.ɪ.əns/

Comment s’entraîner avec cette vidéo

Écoutez la vidéo en entier une fois sans parler et notez les mots que vous ne connaissez pas.
Commencez à la vitesse 0,75×, répétez phrase par phrase, puis revenez à la vitesse normale quand cela devient facile.
Enregistrez-vous et comparez avec l’original, en faisant attention à des mots comme architect, constraint, architectural.

Qu'est-ce que la technique du Shadowing ?

Le Shadowing est une technique d'apprentissage des langues fondée sur la science, développée à l'origine pour la formation des interprètes professionnels. Le principe est simple mais puissant : vous écoutez de l'anglais natif et le répétez immédiatement à voix haute — comme une ombre suivant le locuteur avec un décalage de 1 à 2 secondes. Les recherches montrent une amélioration significative de la précision de la prononciation, de l'intonation, du rythme, des liaisons, de la compréhension orale et de la fluidité.

Technique du shadowing : lire le guide complet étape par étape →

Pratique du Shadowing: What Software Architecture Should Look Like • Dave Farley • GOTO 2022 - Apprendre l'anglais à l'oral avec la vidéo

Choisissez un mode d'entraînement

Télécharger l'application

How to Become a Great Software Developer — Best Advice from Top-Notch Engineers

What is an Organization? - the Nature of Organizations

The Multi-Agent Architecture That Actually Ships — Luke Alvoeiro, Factory

What does an Architect Do?

Inside PMBOK Guide 8: What Project Managers Must Know | Episode 542

Directness with Respect: How to Make the Hard Conversations Easy

Cybersecurity Architecture: Data Security

Course Preview | AZ-104 | Azure Administrator Associate

What Are Microservices Really All About? (And When Not To Use It)

Design Systems vs. Style Guides

Want To Make Your Ideas Stick? Make It Into A Meme!

#02 Common Pitfalls of building Human Resources Strategies