Poll: What Programming Language Do You Use for Server Side Web Development? | Hacker News Reader

Poll: What Programming Language Do You Use for Server Side Web Development?

198 pointsbokenator123 comments

I have been working with PHP steadily over the last year, and, coming from a Rails background (learned it at General Assembly), I used to hate the "ugly" syntax, weird method calls, and strictness of PHP (missing a semicolon can be damnable offense in the eyes of the compiler). Ruby to me seemed a lot more flexible, but over time, after hacking at PHP, I have come to appreciate it as a language that gets the job done.

My preference is still with Ruby on Rails; however, I have been thinking of using a more lightweight framework like Sinatra. I am still impressed with how flexible and expressive Ruby can be. Alongside bash, it has really become one of my favorite languages to work with particularly for scraping/writing automations.

Would love to get into Node, but the idea of javascript on the back-end hurts my head. All I have used Node for is for basic utilities like uglify-js and minifier. Been hacking on Angular and Mithril on the front end, I love javascript as a front end language, but still haven't wrapped my head around Node. Javascript isn't too far off syntax-wise from PHP, but my struggle with Node is how to organize the codebase as well as understanding a clean separation of concerns when it comes to front-end and back-end code.

Might be off topic, but I am really excited to see how the GraalVM is going to impact languages like Javascript and Ruby.

I haven't found a web server language to my liking yet. Maybe I'm too picky, but I'd like to satisfy all of these requirements:

- Static typing -- I want to eliminate as many runtime bugs as I can

- Type inference -- Like in SML and Haskell

- No JVM -- Personal preference, but I'd rather not pull in this monster if I don't have to.

- Good pre-made web framework -- I've briefly looked at OCaml but the web frameworks seem disappointing. Tell me if I'm wrong!

There are a couple Haskell frameworks that might fit the bill. Yesod is a big one, although some take issue with its excessive use of Template Haskell. Others to look at would include Servant, and the very confusingly named rest framework.

With .NET Core having recently hit 1.0[1], wouldn't C#/ASP.NET Core fit the bill now?

[1] https://blogs.msdn.microsoft.com/dotnet/2016/06/27/announcin...

It sounds like they might prefer F# over C#. Also, if they're not willing to pull in the JVM, it seems unlikely they'd be happy about pulling in the CLR.

.NET Core makes the CLR dependency a little easier to swallow. It's modular, so you can only pull in the stuff (packages) you need. Cuts down on the bloat and "CLR kitchen sink" quite a bit.

Doesn't Go fit these requirements?

Go has a relatively weak, unsafe type system despite being statically typed. Also, lack of generics, optionals or tagged unions is kind of a bummer.

I have very similar requirements, and I think within the next few years, Swift will fill this niche very well.

Agreed, Vapor[1] is coming along nicely.

1 - https://github.com/qutheory/vapor

The nice thing about the JVM is that it's contained and has excellent monitoring and profiling tools.

Anyway: What about kotlin [0]?

* 100% java compatible * can compile to the JVM and javascript, so you should be able to run it with node.

[0]: https://kotlinlang.org/

Googling found this: https://jonninja.github.io/node.kt/

We use Kotlin. Their JS transpiler stuff is still pretty new, though they are back to working on it post 1.0.

If you use Kotlin, use the JVM - at least for now.

Doesn't Spring Boot support Kotlin?

https://start.spring.io

I will be revisiting OCaml sometime in the near future to write a more solid web framework for it (compared to OWebl). This time it will be based on FastCGI rather than doing the networking itself I think.

In the meantime, I'm more actively working on Ponyo for Standard ML right now. Take a look at the ponyo.org server[0] for a brief glance at what it can do today.

Check out the /r/sml wiki if you are trying to get started. And please join #sml on Freenode if you have any questions!

[0] https://github.com/eatonphil/ponyo/blob/master/site/server/s...

With type hints in Python 3.5+, does Python fit your list? Genuinely curious.

Just to add some details:

- Static typing -- Type hints enable restriction of the dynamic typing behavior of default Python to mimic static types

- Type inference -- Not familiar with the particular behavior of type inference of Haskell, but yes.

- No JVM -- Definitely no JVM, but not particularly high performance so...there is that.

- Good pre-made web framework -- Lots of good ones, Python ecosystem is fairly rich in general, but ones I have used: Django, Pyramid, Flask, etc.

That's a really good point! I have used the CherryPy framework before, but I've never used Python type hints before.

You need Elixir with the Phoenix framework!

Isn't Elixir dynamically typed?

Modern JVM based frameworks are far from being "monsters", and you have a lot, lot of choices! Many of them have an embedded HTTP server so they are very easy to develop and deploy.

In case you want to investigate some:

- https://grails.org

- http://sparkjava.com

- https://www.playframework.com

- http://projects.spring.io/spring-boot

- https://www.spincast.org

- http://jooby.org

- http://www.ninjaframework.org/

- http://www.dropwizard.io/0.9.3/docs/

Check out Ur/Web[1].

It's a functional, pure and statically typed language inspired by Haskell. It claims that programs that compile successfully cannot:

- Suffer from any kinds of code-injection attacks

- Return invalid HTML

- Contain dead intra-application links

- Have mismatches between HTML forms and the fields expected by their handlers

- Include client-side code that makes incorrect assumptions about the "AJAX"-style services that the remote web server provides

- Attempt invalid SQL queries

- Use improper marshaling or unmarshaling in communication with SQL databases or between

[1]: http://www.impredicative.com/ur/

What about Rust?

It has static typing, limited type inference (function parameters need their types declared - by design - will infer otherwise), no JVM, and has several web frameworks. Not sure if any of them would be considered "good" by your definition, but check it out: https://github.com/flosse/rust-web-framework-comparison

Rust is exactly the language I want for the web. Unfortunately, the ecosystem is still a little too immature. In time...someday...

I've already decided my next service/api will be in Rust.

For an ecosystem overview: http://www.arewewebyet.org/

Still is early days, but there's a lot of stuff too. Excited to see it develop further.

Rust has:

- Static typing

- Type inference (and pattern matching)

- No dependency on JVM, .NET, or BEAM

But the number of web frameworks, etc. for Rust sucks compared to that of older languages like Go. Go 1.0 was released in early 2012 and Rust 1.0 in May 2015.

Rust is more verbose than Go, but Go's FFI to functions written in C isn't as efficient and since "cgo isn't go", I'm not sure cgo covered by Go 1.0 compatibility guarantee.

On the other hand, Go has tons of "batteries included" plus web frameworks so that is pretty awesome to have on stable platforms (I don't consider Windows a stable platform for Go and got burned several times, but Go works great on FreeBSD & Ubuntu.)

I suspect Go & Swift won't have robust reliability on Windows (compared to other platforms) but they'll be rock solid on the ones they favor. Rust may have better prospects regarding this, but Rust still too new this year for web server language -- wait until MIR is integrated and a couple more releases after that.

I've just started using D for this sort of thing. It has web framework called Vibe.d (http://vibed.org/). I'm pretty happy with it, and it seems to satisfy all of your requirements. Note that I've only just started to use it, so I don't know how well it will hold up over time, but I'm enjoying it so far.

Maybe Typescript? (On Node.js obviously for server side).

PHP. It may be old, tricky to debug, and cumbersome to write long projects with but the ability to bounce in and out of logic on a simple, proven, well adopted stack that has plenty of knowledge-base and ready machines everywhere has it's advantages. Plus, I've heard a lot of developers knock PHP but I've yet to see a problem solved with Ruby or Python that couldn't have been solved with PHP.

That last sentence is pretty true of any combination of languages and it feels defensive.

It is and it is.

Its pretty much the definition of Turing complete.

After about a decade programming PHP, I'm now mostly using java 8 (play framework), with some node.js thrown in on the side. I've found that PHP's benefits are also its downsides. The simplistic concurrency model where every request starts from a blank slate and has no asynchronicity is easy to understand, but difficult to optimize for performance. The large knowledge base is great for getting a solution, not so great for getting the right solution. The "just keep going" error handling philosophy is excellent for newbie programmers, but terrible for guaranteeing correct operation. The interpreted zero-build dev model is excellent for quick edit-reload cycles, not so great for large-scale refactorings where you want to know you've correctly adapted all uses of a core api.

Java has improved a lot from what I remember it used to be. Java 8's elimination of a lot of the boilerplate, coupled with the simplicity of the play framework, and activator's hot reloading of code for quick edit-reload cycles brings it on par with PHP as far as developer comfort is concerned, at least for me. In my experience java is nicer for large-scale web dev, while PHP is nicer for a quick side project. Node with javascript I would put more in the PHP camp than the Java camp. It is great for side projects, but scaling it up necessitates switching languages to something like typescript with a whole-project build, which takes away much of the "ease" that something like PHP or Node provides.

I still use PHP for a very simple reason: stable libraries and extremely well done documentation.

As a language and general features I prefer by far node.js... but i hate the total lack of decent-level documentation I found over the years.

"Plus, I've heard a lot of developers knock PHP but I've yet to see a problem solved with Ruby or Python that couldn't have been solved with PHP."

Of course. Since all of those languages are Turing-Complete, this is trivially true.

Solving a problem and computing a function are almost entirely unrelated concepts. For instance, solving a problem usually takes the form of "write a system which can do X, within budget, on schedule, in a maintainable way, with integration with these services, with at least this much reliability." Out of that list, the only thing a function can compute there is to do X, once. And maybe not even that; functions can't even do I/O.

Unless you have developers who are super excited about writing web services via BPF filters, Turing-completeness is not a meaningful way to compare programming languages; that is, that's not the reason why we have multiple programming languages in the world and why different people or projects prefer different ones.

"I've yet to see a problem solved with Ruby or Python that couldn't have been solved with PHP"

Scientific computing is extremely strong in Python - numpy, scipy, scikit-learn etc - and a lot of it makes use of language features that aren't present in PHP (at least as-of a few years ago, my PHP experience is rusty at this point).

Languages that are cool/hip/popular here will win.

Odd that Golang was left out with it fitting that criteria... but I still stand by the assertion :)

"Go" is in the list. Perhaps you just missed it?

Edit: I see, based on other comments, that Go wasn't part of the original lineup.

I saw it just now, so by now its already added and stands 6th most used (not bad for a relatively new language) for server side web development.

I like it a lot, have been using it since 2013. I bet its going to rise in usage.

A minor point regarding its name usage. We should always call it Golang on HN & comments etc or in searches, as 'Go' is such a common word. I always try to to a ctrl-f for golang. And I am sure many other gophers do.

Python. Django or Flask depending on the projects' needs

Elixir

Edit: I wrote this comment before Elixir was added to the poll.

Elixir and Ruby at work (previously Go as well). I have also done backend development in JavaScript, PHP, Python and Clojure.

Elixir is certainly my favorite to work with, so far.

Was Go phased out leaving Elixir/Ruby, or was that at a different company?

Neither, still running Go for a standalone service in production just fine. There hasn't been a need to work on it for quite a while.

No option for Go?

PSA: Don't forget to up-vote the poll itself.

The people using Haskell should write more blog posts about using it in production.

PSA: Just upvote the poll up above, no need to add your comments in the comments below.

Comment: As a follow up, it would be interesting to see which framework people use within the language.

I appreciated the lisp and clojure options; I use racket/typed racket - for no other reason than that it's a lot of fun.

Go ?

Java and Groovy, mostly. More Groovy (via Grails) for web specific stuff, sometimes plain vanilla Java for backend services. Nothing is off the table though... I'll happily use Scala, C++, Haskell, Python, Rust, Go, or Intercal, if there's a good justification for it in a specific situation.

Now that Go has been added, I see a good amount of votes for Go.

Since we're talking about server-side web apps, I'm assuming this entails an HTTPS API endpoint, some datasource, and some business logic. What packages/libraries/toolkits to you use to build a (micro-)service such as this?

Scala

PHP ... It's like a fine wine that gets better with age, really.

Python(Django and pydata stack). Most surprising to me, there has been a huge uptake of Python in my country (Kenya) this year. Ruby didn't win. Neither did JavaScript.

I use PHP for a long time. But now I see Python and JavaScript are the most used languages. I just wonder which one of them will be a true choise after PHP?

Both, neither, does it really matter? In my experience any server-side programming language will be good enough for 99% of the websites out there. Once you get up to the size of a google, twitter, facebook, etc. then you can start worrying about which server-side language you should use. Otherwise just use whichever one you prefer.

But the PHP looks like it's going to die. So how can you explain popularity of Python and JavaScript? PHP, Python and JavaScript; all of them can make same job? Any differences in performance?

Yes, they can all do the same job and for all practical purposes they don't have any difference in performance. Just pick whichever one you prefer. If you become the next google then you can start worrying about the performance of your server-side language.

Considering the general HN bias towards newer languages, I am impressed (very) by Java's standing. A good language to be pigeonholed in I suppose.

I tried Node/Restify, but I just can't problem-solve using those tools, so I went back to ASP.NET/Web API using C#.

Javascript with proprietary API at work (not NodeJS)

Java for not work (I want to move away from Java so I won't get sued by Oracle)

Java at work and python for side projects

Ruby on Rails for one simple reason - it's still the fastest way to build small and mid-size web apps.

Just added go

I use php not because it's better than Java (for example) but because I know it better :)

Python

Nim

Which framework if any?

Implementing HTTP routing and HTML templating is easy enough in Nim, but Jester is handy: https://github.com/dom96/jester/

Swift

Someday in production!

What hosting provider? IBM?

Digital Ocean

I've been interested in using Swift for webapp too. Anyone has recommendation for a good framework?

I wrote this post the other day comparing four of the top Swift web frameworks on GitHub, maybe this will help?

https://stormpath.com/blog/swift-on-the-server-today

Be aware that all of the frameworks are targeting Swift 3 right now, so it's a bit unstable until Swift 3 is officially released. But the ecosystem is going really strong =]

I'm using Vapor on a new project and I really like it. The biggest stumbling block at the moment is that the Swift Package Manager can't resolve packages having dependencies on different versions of other packages. I'm using Vapor with Zewo's PostgreSQL ORM, and upgrading either one is an exercise in frustration.

Groovy

Despite the apparent lack of popularity, Groovy with the Grails framework is certainly better suited for web development than many (I would dare to say, most) of the programming languages listed above. Of course, it also matters what kind of web development we are talking about. Is it web services or web applications? I think the requirements are quite different between the two.

After its leadership changed in 2005, Groovy was commandeered to be primarily a scripting language for Grails. A Ruby-like meta-object protocol was added to Groovy so Grails would be Rails-like. Groovy's never really broken free of this shackle, despite its failure around static typing and Android, or use for defining builds before Gradle 3.

Pascal

Can you elaborate on this?

See: https://deusu.org

The backend is written in Pascal.

With the exception of the blog. That is written in Node.js. I did that as a way to learn Node.js. But as soon as I find some time I'll rewrite that in Pascal too.

I probably should also add that I'm using FreePascal - not Delphi - and that the servers are a mix of Windows and Linux.

Elixir

From the comments, seems like Other=Go ;) I'm in that camp too.

Python: cherrypy -- avoid django and flask as much as possible.

Ruby, Elixir and under certain conditions, Javascript (NodeJS)

Node at work and for quick projects, Elixir for fun.

Java and Ruby at work, depending on the project.

Java, sometimes node/js on side projects.

Java, Go and Node depending on requirements.

Clojure (recently) and PHP (legacy)

Rust

Scala

Racket

Golang

See: Go.

Python (Django)

CFML

Python

ruby and dlang

Dogescript.

I mean, it compiles into Javascript. It didn't take long before I realized that I could write an entire Node-based web app entirely in DS.

Much users. Very rich.

Here we go again with JavaScript. Can't wait for this cycle to go back down like it did back when jQuery and Node first came out and everyone jumped on the bandwagon.

After all this time it's still interesting to see how much hate there is out there for JavaScript even though it has proven itself a more that capable language across multiple platforms.

It's not so much the hate for JavaScript. It's the hate for the developers who know nothing about computing history making all the same mistakes as with any other platform while being so darned insistent that the world will run only on JavaScript any day now because JavaScript is the uber language.

You meet a young hip developer at the train station, the train is 8 minutes late so you have a moment to talk. They tell you they love JavaScript above all else, after a brief rant about how great lexical scoping and arrow functions are in ES6 you can finally get a word in edgewise.

What pieces of advice do you offer so that this poor child may avoid the mistakes of his forebears?

More than anything I would say stay slightly behind the hype wave.

Take two steps back and one can see the waves of hype roll through programming blogs, HN and reddit. 10 years ago people were arguing over ORMs. Then it was dependancy injection frameworks, then SQL vs NoSQL. Now there's JavaScript and it's various frameworks and libraries. THere's always so much hype about what to use that it's easy to lost in it and worry that if you aren't riding the trend wave, you'll drown. But most times it's easier just to float a while and watch from a short distance. Get done what you need to get done with what you currently know. Let the hype die down. Learning new things is a ton of fun. But they can be devilish to deploy in production. Don't feel like you have to use them.

Edit: I'm not saying DI frameworks, or ORMs or NoSQL (or even SQL) are bad in any way. Just that within each topic there was much arguing about what is "the best" or "proper" or whatever. Wait for that to cool off and die down before betting your next project on it.

They're not waves, they're cycles, with each successive generation rediscovering the lessons of the previous generation. I found it particularly amusing to see javascript front-end developers struggle with model/view binding strategies a few years back knowing that all of this was already hashed out by desktop developers in the 90's and terminal interface developers in the 70's. Still, react came out of that, and I don't think the desktop ever had an equivalent to react, at least not in the 90's. So every once in a while a genuinely novel idea pops up, but they're rare.

Citing Alan Kay on the difficulties of keeping up with tech:

We are fortunate that most of what is "new" is more like "particular 'news'" rather than actually "new". From the standpoint of actual categorical change, things have been very slow the last 30 years or so.

Even react is based on 4 decade old ideas; Component based programming (at least the idea of it) has been around since the 60's.

I wouldn't say components is the novel idea in react. For me the novel idea is continually generating the entire ui by applying functions to data. Previous component-based frameworks were about static declaratively-described ui's that where then bound to data, which is in many ways an inferior approach.

"developers who know nothing about computing history"

I guess it depends on what time scale you are using to define computing history. JavaScript hasn't been 'new' for a long time.

I've been a web programmer for about 20yrs and have used ASP, ColdFusion, Java, C#, PHP, and JavaScript professionally and for me it is the language I enjoy using/writing the most. It continually surprises with new and more powerful innovations and implementations: from the early days of DHTML to AJAX, closures, Node, React, Tessel, etc.

I'm curious as to what more would have to be done with the language for it to graduate to 'real' language status.

Heck even NASA thinks it's good enough: https://vimeo.com/168064722

I ... didn't say JavaScript wasn't a 'real' language...

Reply on news.ycombinator.com