"Impact of front-end architecture on development cost", Viktor Turskyi

Frontend development
approaches that reduce the risks
of project failure
Viktor Turskyi

JavaScript fwdays’24
● 20 years in IT
● 13 years in software business
● Delivered more than 80 projects of
different scale
● Did 15 projects for 5 companies from
Fortune 500 list
● 3 years at Google
● youtube.com/@AboutProgramming

Is High Quality Software Worth
the Cost?

Do we need architecture for
frontend?

“If you think good architecture is
expensive, try bad architecture.”
—Brian Foote and Joseph Yoder

What is most popular
architecture today?

Big Ball of Mud
http://www.laputan.org/mud/mud.html#BigBallOfMud

Source: https://martinfowler.com/articles/is-quality-worth-cost.html

What is the best architectural
decision?

Robert Martin
“The job of architect is not to make decision, the
job of the architect is to defer decisions as long
as possible”
“Good architecture maximizes number of
decisions not made”
https://www.youtube.com/watch?v=o_TH-Y78tt4

How can we make better
architectural decisions?

Solution is in technical domain
but problem statement in
business/product domain.

Understand business/product
domain. Focus on business
problems

Why to understand domain?
● Problems you solve comes from domain. Otherwise you will solve wrong problems.
● Requirements (including non functional) comes from domain.
● Creating good Domain Model requires understanding the domain
● Simpliﬁes communication with stakeholders (you talk to them using their
language)
● Simpliﬁes adding new changes
● Psychological comfort. Engineers prefer to write products that they understand.

Conduct business/product
trainings

Universal approach for better decisions
1. Always ask yourself “What problem do we want to solve?”
2. Find several potential solutions (not all possible, two can be enough)
3. Select the best solution for your problem
Let’s discuss problem microservices case again.

How to make “better” design?
● Understand business/product domain
● Understand technologies deeply
● Optimize for change
● Assemble ﬁrst
● Think about abstractions

Why to understand technologies deeply?
● You cannot choose right technologies without knowing their properties
● You cannot know their properties without knowing implementation details
What will happen to DB if you will increase amount of data 10 times? Can you answer
that without knowing how indexes work?
Docker vs VMs? What are the properties? (Why docker is slow on OSX?)
Is MongoID secure as a token for password recovery?
React Native is native or not native?

Optimize for
change
One of Agile Manifesto principles:
Welcome changing requirements, even late in
development. Agile processes harness change
for the customer's competitive advantage.
https://agilemanifesto.org/principles.html

How to optimize for change?
● Do not write code which support everything. In this case, the result will be
opposite.
● Expect changes! Evaluate risks
● Simplify (simplicity and easiness is not the same, “Simple made easy”)!
● Good abstraction but without overengineering. Reduce coupling, increase
cohesion.
● Stay in touch with product managers (while you developing A they are already
thinking about B)

Can we predict future?

Talk to product managers - they
live in future

Assemble ﬁrst principle

https://webbylab.com/cases/mercedes/

How to organize work on this?

What does it mean to assemble ﬁrst?
● Create abstractions
● Think about data which goes through your system
● Implement behaviour just with simple boxes
● Iteratively add details to each box

Why to assemble ﬁrst?
● You will have abstractions of components that really ﬁt each other
● You will have end-to-end working functionality early to and will get early feedback
● Feature owners can test their own pieces in fully working environment
● You can discover risks as earlier
● Early integration becomes possible
● Much easier to parallelize the work
● Not having time to deliver 100% will allow you to compromise on some visuals
than on end-to-end experience for case when you assemble at the very end

https://blog.udemy.com/how-to-draw-a-realistic-cat-step-by-step/

Does it guarantee success? No!

Priorities/Commitment
P0 - must
P1 - should
P2 - might

https://blog.udemy.com/how-to-draw-a-realistic-cat-step-by-step/
P0, P1, P2 P0, P1
P0

Abstractions

What are good abstractions
● They are usable. Think how they will be used while designing them
● You can understand them. You should be able to predict system behaviour
● You should know where to put speciﬁc code
● Tests are just statistical proofs that something is working
● They are not dependent on context
● Low coupling
● High cohesion

Developes are afraid of new abstractions
● Story about Test factory and assertDate method
● Story about Controllers/Mediators/Managers in UI
● Story about Extra behaviour in slides engine
● Story about Builders for UI components
● etc

Level editors concept

Universal toolkits

Builders

Type of builders
● Form Builder
● Dialog Builder
● Grid Builder
● Page Builder

Form builder schema
{
api: { load: (id) => {} , save: (data) => {}},
inputs: [
{ﬁeld: ‘name’, type: ‘text’, label: ‘Name’}
],
}

Form builder
function UserEditForm({id}) {
const schema = {...}
return <FormBuilder schema={schema} />
}

Dialog builder
function UserEditDialog({id}) {
const schema = {
title: ‘Edit dialog’,
formSchema: {}
}
return <DialogBuilder schema={schema} />
}

Grid builder schema
source: { list: Promise.resolve(data)},
columns: [
{field: ‘id’, type: ‘id’, label: ‘Id’},
{field: ‘name’, type: ‘url’, label: ‘Name’, urlFormatter: (user) => `/users/${user.id}`}
],
rowActions: [
{icon: <DeleteIcon />, label: ‘Delete’, confirm: true },
{icon: <EditIcon />, label: ‘Edit’, action: (row) => {
dialogService.open(UserEditDialog, {id: row.id})
}],

Grid builder
function UsersGrid() {
const schema = {...}
return <GridBulder schema={schema} />
}

Page builder
{
title: ‘users’,
layout: {component: MainLayout, props: {selected: ‘users’} },
gridSchema: {...},
}

Builders pros
● You have consistent behaviour across your UI
● Increases development speed a lot
● Can be iteratively updated each time you have a new requirement
● Easier to design
● Minimum extra time for development as the features should be done in any case

Is technical debt a bad thing?

Some thoughts on technical debt
● Doing things the quick and dirty way sets us up with a “technical debt”, which is
similar to a ﬁnancial debt.
● Another metaphor is “Pollution”. Pollutants gradually affect people and as time
passes by, makes it exponentially harder and costly to ﬁx it.
● You can't cook food without dirtying the dishes. Clean the kitchen after cooking
● You introduce technical debt even if all you do is just write similar code.

Some thoughts on patterns and best
practices
Pattern is just a common solution (not a secret solution) which works for a common
problem.
Ask yourself why such pattern or best practice does exist and be ready to not follow it if
this “why” is not related to your case.

Chat example
Let’s design together

@turskyi
Viktor
Turskyi
Thank you

"Impact of front-end architecture on development cost", Viktor Turskyi

More Related Content

Similar to "Impact of front-end architecture on development cost", Viktor Turskyi (20)

More from Fwdays (20)

Recently uploaded (20)

"Impact of front-end architecture on development cost", Viktor Turskyi