Front-end development and its reality
Front-end development and its reality
The sentiment that front-end development isn't real
development is unfounded. Front-end development is every bit as difficult and
worthy of the title as any other subset of development. Front-end developers
have to deal with cross-browser compatibility, develop for multiple screen
sizes and input types, and make choices about frameworks, libraries,
preprocessing, dependencies, and plugins. They are responsible for design,
content, and user input. Naming things, copywriting, and CSS testing are also
difficult tasks. JavaScript is just as complex as any other programming
language, and front-end developers are responsible for optimizing website
loading time and ensuring accessibility. Therefore, front-end development is a
complex and challenging field that requires expertise and experience.
Front-end
development isn’t real development?
There
is some sentiment out there that front-end development isn’t real development.
It’s a swaggering, trollish sentiment. Still, it’s fun to puff our chests back
sometimes. Let’s try to put a point on why front-end development is every bit
as difficult and worthy of the title as any other subset.
The
practice of front end development is similar to playing the bass: it’s easy to
learn but difficult to master. There is a lot more to it than HTML and CSS .
We
have to deal with cross browser compatibility.
This
was far and away the most cited gripe in the group. While Internet Explorer
continues to be the brunt of most jokes, every browser has its own quirks that
often require special development techniques to overcome.
It’s
rather expected of us that we know how to build websites that can work
cross-browser. We should know what browsers support what and how to debug and
overcome browser-specific issues. We should know how to do emulate or otherwise
test on a variety of browsers.
We
should know tools that help us with cross-browser problems either automatically
or enable us to write code to handle situations of support and nonsupport of
features. We should know how to do fallbacks. We should know about progressive
enhancement and graceful degradation.
Cross-browser
compatibility is a hugely complex development task.
In
addition to dealing with browser inconsistencies, front-end developers are also
charged with developing for as many screen sizes, screen orientations, pixel
densities, and input types as possible.
The
burden of the massive landscape of different screens, browsers, and
capabilities lies most heavily on front-end developers.
Frameworks,
libraries, preprocessing, dependencies, plugins… It used to be that linking up
a stylesheet and maybe a JavaScript file in the HTML was all that was needed to
start designing and building a site. In fact, that’s still the baseline.
Today’s
development feels a lot different. The tool chain is a lot thicker. We’re
making choices about build processes, which libraries to use, what languages to
write in, how invested in future syntaxes we want to be, how much we want to
depend on frameworks, which third-party tools make sense and feel safe to use.
Not
only is it fatiguing to think about the choices, it’s increasingly difficult to
know what the best choices are and if these choices are smart in the long term.
There
are just as many choices, or more, at the front end level of development than
there are anywhere else. Not to mention the landscape moves extremely quickly.
Many
of today’s frameworks and CMS’s, straddle the line between lots of different
disciplines. Front-end developers are right in the middle of it all. We’re
ultimately responsible for design—how the site looks. We’re helping content
people ensure they have what they need and they give us what we need. We’re
working in templates prying out the data we need in the formats we need. We’re
handling user input and ensuring it funneling where it goes for more back-end
concerns.
The
barrier to entry for front-end development is fairly low. Everyone has heard of
HTML. They “know enough to be dangerous” as it were. Because that barrier is
low and because it’ so easy to dabble, it makes sense people assume there isn’t
that much to know and that front-end development isn’t particularly difficult.
The
maxim about naming things being one of the hardest problems in computer
science. Us front-enders are naming things all the time. Class names and IDs,
data attributes, file names, communicating patterns with your team. It’s
endless. It feels like there are dozens of name choices on an average day. Not
to mention the task of copywriting often falls to us, which isn’t quite naming
but is in a similar vein of difficulty.
“The
right way” and “the wrong way” aren’t as cut and dry as with back-end
development. In back-end development, if what you are expecting to happen
happens, you’ve succeeded. Surely they are different ways to get there, some
better than others. But in front-end development, the paths to completing a
task seem endless. Even if you’ve seemingly succeeded, it can feel like just a
matter of time until a bug is found in how you’ve done it.
CSS
is very hard to test. Back-end languages (and even JavaScript) can use unit
testing and integration testing to help make sure the code works as expected.
CSS has no such luxury. There are certainly people trying and there is some
information and tools out there. But none of it is all that great and there are
very few success stories.
Bugs
can be subtle, confusing, and unexpected. Worse, a seemingly little change may
have an adverse effect in an unexpected place where you don’t notice until it’s
too late.
There
are linting tools, which help a little. There are some style guide enforcement
tools, but they don’t really help enforce more important things like adherence
to naming standards.
Front
end developers need to hold a very strong understanding of the entire website
in their head in order to be most effective and efficient.
JavaScript
is just as complex as any other programming language. It’s weird and hard.
JavaScript is front-end development. JavaScript is programming. Programming is
part of software development. Software development is hard.
The
rule of thumb is that 20% of the waiting for a website to load is from back-end
concerns. Once HTML document has arrived, the rest of loading time is the
concern of front-end developers. What resources are loaded, how many resources
are loaded, how optimized they are, in what fashion they load in and how that
feels, etc.
It’s
where accessibility happens.
Building
sites that are visually stunning is one thing and the accessibility of them is
another. Designers care very much how users interact with a site and that might
not always be a visual interaction. Designing and developing for disabilities
is a discipline unto itself, but is most tightly tied to front-end development.
Accessibility has its own set of specifications that sadly aren’t typically
taught along with traditional front-end development training.
It’s
hard to hire for. Front-end developers are typically the hardest seats to fill.
So front-end development is“real” development.
Written
by D Roy, DOCC Kolkata. , Web design and Development Trainer. Visit
www.docckolkata.com / Call 9433526196
Comments
Post a Comment