
Ask HN: What is a “boring” web stack? - stevetodd
There have been threads recently lamenting how many in the web community often chase new and shiny. Many advocate choosing &quot;boring,&quot; tried-and-true technologies for the web. What are the &quot;boring&quot; stacks that you see successfully used for the web? If you were starting a new web project today, what would your &quot;boring&quot; stack look like?
======
jordanlev
Ye old "LAMP" stack (Linux, Apache, MySQL, PHP) is pretty boring, and widely
used. Very stable, very performant (and lots of options for caching / indexing
/ tweaking code when you encounter bottlenecks). Lots of competition in the
hosting space as well, and you're not locked into any one company's flavor of
"cloud computing platform".

~~~
warlox
But then you have to use PHP.

~~~
soulchild37
You upload PHP file to your server, done. No deploy task and stuff.

~~~
seanwilson
That's fine for experimenting but sounds terrible when you want to track down
where problems came from and rolling back.

~~~
1123581321
There are plenty of testing, deployment and analysis tools for PHP apps.

------
detaro
Ruby on Rails or Django for the backend, some basic JS (JQuery and other
libraries of similar complexity) for the front-end. Choice of JS tools mostly
depends on how much front-end features you need.

~~~
ThrustVectoring
The persistence layer is also a thing, and the boring choice is something like
Postgres or MySQL.

~~~
StavrosK
At least at the persistence layer, there's a clear default: Postgres will do
everything you want, and it'll be hard to outgrow.

~~~
paulfurtado
What things would you say make Postgres a "clear default" over MySQL?

~~~
adictator
Honestly, features & stability wise, MySQL is a toy compared to Postgresql. I
still feel Postgresql does not have as big a market share as it could, mainly
because of how difficult it is to pronounce it right. On the other hand, MySQL
got away with a rather sweet name. But for any serious work, I would trust
Postgres (there, I did it!!) more than any variant of MySQL.

~~~
mcpherrinm
I think especially in the context of a "boring" web stack, MySQL is the clear
winner.

Postgres has lots of shiny features on the SQL side, but MySQL's storage and
especially replication has always been more reliable for me. I've seen a
couple failed MySQL -> Postgres migrations because it's the shiny thing people
chase, but the operational reality is that MySQL is still better.

~~~
ThrustVectoring
As an application developer, I remember wrestling with some really annoying
stuff on the application side to deal with MySQL. IIRC, it was something like
the default ORM for a python-based framework requiring a reflection API that
Postgres and SQLite have and MySQL doesn't. This and other war stories
probably generalizes to many other application developers preferring Postgres,
but there's a ton of people using MySQL, so that probably means that it solves
a bunch of the problems that the wizards in operations have.

That's why I listed both. I'd use and recommend Postgres as a default in a
heartbeat based off personal experience, but I wouldn't have personal
experience with MySQL's strengths and people use and recommend it as well.

------
ronilan
I think "boring" is another word for "not frustrating".

I recently did a project where I wrote the same API in Ruby/Sinatra,
Node/Express and PHP/Slim; Connected it to S3, GCloud and Azure for assets and
MongoDb for data; and then deployed each permutation to Heroku, Azure, App
Engine and EB.

For "under the api barrier", Heroku was the only one that ran everything
smoothly; S3 is the easiest to interact with, and as I worked through the
project, I switched from Ruby to Node as the prefered platform.

For "over the api barrier", where users actually use the project, it depends
on the project requirements. In this case no dependancies was a hard
requirement, hence Vanilla JS. But if you have a lot of UI, you'd need a lib
for both JS and CSS and it depends on teammates pref, organization pref and
legacy.

My 2 cents.

------
anon1253
Server side rendered HTML, simple forms with POST redirects. Little to no CSS
or Javascript. Pick your back-end of choice: Java Spring, Python Django,
Common Lisp (wink wink). Use a well known SQL server for persistence. Might be
boring, but there are still a lot of cases where this is actually desirable,
and it's insanely performant.

~~~
warlox
At this point, isn't a site without CSS only suitable for tenured academics
who don't care about their personal websites?

~~~
johan_larson
Have you seen this? No CSS, but it looks OK.

[http://motherfuckingwebsite.com/](http://motherfuckingwebsite.com/)

Using absolutely no CSS at all probably isn't what you want, unless you have a
fetish for serif fonts. But a little can go a long way.

------
StavrosK
Java, the Microsoft stack, Django, RoR, anything that's been around for more
than five years. I don't include PHP there because I don't think the language
is predictable/consistent enough, same as JS.

------
cableshaft
ASP.NET MVC5 C# + Angular 1, because that's what we do at work and what I'm
currently most familiar with. It's a pretty solid way to go if you don't mind
Microsoft technologies, either. Although ASP.NET Core is probably more future-
proof.

~~~
kirse
+1... ASP.NET / ReactJS.NET has been great for me. I've done so many
small->med projects on ASP.NET MVC / EF / SQL with some F# mixed in for fun
and it just works. Toss in ELMAH for easy error logging.

Testing + deploying to either Azure/IIS is also one-click simple and very easy
to teach Jr. Devs to step into a solution and become productive with very
little guidance.

------
andrewmcwatters
I know this doesn't _truly_ really answer what you're asking, but: GitHub
Pages, static HTML, no or plain JavaScript, plain CSS, no frameworks.

You can do a lot with just that. Here's an example of what I've done with just
that:

[http://www.planimeter.org/grid-sdk/](http://www.planimeter.org/grid-sdk/)

[http://www.andrewmcwatters.com](http://www.andrewmcwatters.com)

------
lastofus
Pick anything that's still heavily used today, that has been around for 10+
years, and it's hard to go wrong.

The only caveat to this is on the front-end JS side of things. jQuery is still
solid, but the language and ecosystem has been so not great over the last
decade that something a bit newer might be worth looking at (maybe look at 3-5
year old libs/frameworks instead).

------
foobarchu
In the enterprise world, a boring stack is usually Java 7, 8 if you're
adventurous, with Spring as the backing framework, running on a Tomcat server,
talking to a SQL database (Mysql, Postgres, Oracle) through a Hibernate layer.

None of these are really great technologies, but they work, have infinite
documentation, and it's easy to find people who know them.

~~~
eecks
Can you name any "great" technologies in place of each of these?

~~~
foobarchu
That's in the eye of the beholder, and definitely depends on the situation.
The good thing about the boring tools is that they have really wide
applicability.

For a small REST api, I really like Dropwizard on top of something with a
solid raw driver, like Redis or Cassandra. If you want to go relational, I
like the MyBatis model of persistence over the Hibernate style ORM, it gives
you so much more flexibility and power over modeling, while still giving you
an easy out for swapping out datasources.

I don't really know of a good drop-in replacement for what Spring does,
unfortunately, because Spring is really a conglomeration of so much different
stuff. My big issue with it isn't so much what it does, as the fact that it
encourages really bad mindsets in developers who start their career with it. I
can't count the number of times I've asked someone to describe what
annotations are, and the only answer they can give is about Spring (the worst
part is when they attribute things from Jersey or JPA to Spring), or how they
reduce the need for XML configuration (in Spring, yeah, that is true).

------
johan_larson
Angular/Bootstrap on the front end. Java with Spring Boot on the server. MySQL
for storage. Deploy on AWS.

Nobody's idea of excitement.

~~~
bjconlan
Haha, but there is always a way to make this less vanilla than people would
expect. Ie adding Spring 5 (alpha) reactive web layer & I still love hateoas
(spring/data-rest) but adds a little too much extra complexity for the benefit
(on the client).

I miss well tested and 'best practice' pattern derived systems...

------
1_800_UNICORN
Java, Ruby, PHP - all safe bets for server-side language. They're all easy to
find developers for, stable, and easily supported by all major IaaSes (AWS,
Google Cloud Platform, Azure) and PaaSes (Cloud Foundry, Heroku, Kubernetes,
Docker).

Javascript - either no Javascript, or very simple vanilla Javascript. No
transpiling, no Typescript, no JSX, no ES2015.

CSS - Regular ol' CSS. Set a limit on number of lines of CSS you're willing to
introduce per controller action and try and keep your project honest to that
number. Avoid frameworks if possible, pick a simple framework for grid layout
if you really need it.

------
cphoover
Is picking a a "boring" for the sake of "boring" stack really all that
sensible? How about we choose things because of tangible reasons, like test
coverage, infrastructural/operational simplicity, availability of development
resources, industry/enterprise adoption. IMHO these are the things that make
sense when choosing a framework/language. Choosing something just because it's
old and boring is illogical.

~~~
MichaelBurge
"boring" means "of low technical risk" in this context.

------
gravypod
PHP with some template library. Pretty much gets the jobs done and stays out
of your way. RainTPL[0] is the best template engine I've ever used since it is
just so simple to understand what's going on.

[0] - [https://github.com/feulf/raintpl](https://github.com/feulf/raintpl)

------
stuaxo
Plain Django with Postgres.

Django templating and bootstrap to make things look OK.

------
totony
I did most of my website dev with PHP, js, css and html, no framework (except
jquery at one point). Boring but did the job well

------
juliangoldsmith
I'd call a stack using Golang, Postgres, jQuery, and SASS/Less boring. It
doesn't do much of anything magical, and as a result you can reason about
every part of what you're writing.

------
ohgh1ieD
My boring stack is: Spring, Hibernate, Postgresql, but sometimes when nobody
watches and I feel really nasty, I use the Play framework.

------
quantumhobbit
Well Java is boring...

Actually language doesn't matter so much as choice of frameworks. Basically
choose what you know works and avoid hype.

Also minimalism is a better indicator than age. A brand new simple framework
is better than something old but over engineered.

------
psranga
bottle.py + Postgres + Nginx on Ubuntu on a VPS is my go-to boring stack.

I recommend just using SQLite for the MVP. Launch then iterate.

------
shitgoose
the word _stack_ itself is quite boring.

