For front-end developers, there's a never-ending stream of new things to learn. New frameworks, with new philosophies, seem to be released on a daily basis. How, then, do you pick which one to use? The answer, as it happens, has nothing to do at all with JavaScript.
3. I'VE DONE THIS A BIT BEFORE.
◇ I'm a web developer with a fair bit of
front-end experience.
◇ My last two jobs both involved some
degree of picking a JavaScript
framework.
◇ In fact, I've only had one job where it
didn't come up.
◇ Not to mention personal projects.
◇ It's getting kinda old, honestly.
4. So, if we're going to pick
a JavaScript framework,
we should look at our
options, right?
7. BY THE WAY...
These were all active within the last two
weeks, when I made this presentation
(Oct. 7).
Some are hobbyists, some are big
companies, but all are active projects.
You could maybe double this with "slow"
projects (updates in the last 6 months).
11. EXCEPT...
Those lines are blurry.
An MVC framework can use components
to drive its structure.
A component-driven architecture may or
may not be modular.
There's overlap. It's not clear-cut.
12. So, how do you pick the
right JavaScript
framework out of all that
ambiguity?
18. CODE SCHOOLS
◇ Code schools, and many college CS
programs, advertise that they'll teach
you how to code.
◇ Broader PR language talks about how
everyone should learn to code.
◇ That's all true. And that's all useful.
◇ But coding is not making software.
19. Learning to write code,
but not learning to make
software, causes
problems.
20. CS VERSUS SE
Software is more than the code you write.
It's all of the context that goes into it.
Writing code is a vital step in
implementing software, but so is the
process of finding that context.
Too often, that process is skipped over by
programmers who just want to code.
23. THE PROCESS
Sorry, but this is a software engineering
talk in disguise.
But if you ask the right questions, you'll
end up understanding the project and its
context so well that picking a framework
takes hardly any effort.
So let's ask those questions.
26. WHY?
Why does the problem you're trying to
solve exist?
Was performance never considered?
Is the code poorly built?
Are you just goofing around and learning?
There's no wrong answer, besides having
no answer.
27. WHY?
Sometimes, you'll get requirements that
propose a solution to what they describe.
Asking "why?" offers a gut-check, to make
sure that solution really is the best one.
Also consider why a framework you're
evaluating exists. What problems are its
authors trying to solve? Do they know?
28. The context of the
problem matters more
than the problem itself.
30. WHAT?
Working out why the problem exists helps
to define what the problem really is.
That helps define the features and
capabilities that are going to be
necessary.
Those become your priority.
31. WHAT?
Some tools and frameworks do certain
features really well, and really easily. But
other features may take some work.
Don't discard a framework just because it
doesn't have exactly what you want. You
can build it. Or it may have something
different that achieves the goal instead.
32. Any feature is possible,
but with the wrong tools
some will be difficult.
34. WHO?
You go to war with the army you have.
You, your customer, your users, your
teammates, your company… Everyone
brings perspectives. Expectations. Skills.
Experiences. Ideas.
Politics.
35. WHO?
If your boss says "we're using this
framework", and it's not the best one, you
either have to fight or concede.
If your team already knows a framework
that's not empirically the best, but is still
kinda close, that may be your wisest pick.
Merit rarely wins. Account for this.
36. The people on a project
ultimately determine
what's practical.
38. HOW?
Every framework has a philosophy behind
it. Based on the context you've gathered,
you'll have a philosophy on how the
project should be done.
Now you're just looking for a match.
You'll make better code that way.
39. HOW?
Beyond a certain level of competence-
based best practices, it's not worth
worrying about how pundits write their
code.
If you don't like a popular approach, don't
use it. If you do like it, use it.
You're the one writing the code, after all.
40. Pick the tools that
encourage the kind of
code you can enjoy.
42. REPEAT
You'll hopefully only choose a framework
once, but you should be asking those
questions routinely.
Every quarter, or at the beginning of every
sprint, whatever pace helps keep you
confident you're on the right track and
making the right software.
43. REPEAT
But now, the hard work is done!
All you have to do is implement the ideas
you decided on. But since you did all that
work, the programming will be easier.
You've made the software, you just need
to write the code that powers it.
51. Software has a
personality. It's
more than just
code, it's all the
decisions and
context that went
into it. Understand
those, understand
software.
52. Also:
Software has a life.
It will grow up.
It will grow old.
You can give it the
best chance of
success, but
ultimately, it's out
of your hands.
Accept this.
Embrace this.
53. TWEET AT ME: @HUPFEN
YELL AT ME: ZOE@HUPFEN.COM
Presentation template by SlidesCarnival
Photographs by Death to the Stock Photo
