What technology should my startup use?

Through the years many individuals have requested me the identical query:

I am beginning this new challenge, what expertise do you assume I ought to use?

Usually these individuals slot in one among two classes:

• Technologists who've already made up their thoughts


• Non-technologist entrepreneurs who have to be reassured

On the finish of the day, I doubt that many of those individuals truly cared
about my solutions. They most likely simply wished to know if we have been on the identical web page or wished to be reassured.

To be trustworthy, as an engineer, I imagine an incredible concept will be constructed with nearly any
expertise. All of them have their execs/cons. It doesn't matter what stack you select, you may pay a
sure worth for no matter benefits it affords. However actually, the success or failure of your challenge has extra to do with imaginative and prescient, management, execution, and market than technological decisions.

Now that I am an entrepreneur, I make technical choices each day. Once I select
a selected expertise, I would like to have the ability to justify the choice to myself, my
companions/staff and potential buyers. I make technical decisions primarily based on the challenge and firm's imaginative and prescient.

For a challenge to achieve success you should have a robust imaginative and prescient.
Should you can convert your imaginative and prescient right into a set of values to benchmark each resolution, your path might be clear and it will be simpler to search out the proper individuals to affix you.

Apart from the imaginative and prescient, a number of startups give attention to tradition.
It's generally stated that the tradition is outlined by the founders, the primary few staff, and
the product itself.
Nonetheless, what is not typically talked about is that the technical
choices can have a direct impact on the corporate tradition.

Whether or not your new startup is predicated on J2EE/Oracle, Perl, PHP, Rails, Node.js or
.NET, the crew's engineers can have completely different expectations, completely different
values, and completely different considerations. None of those applied sciences are intrinsically dangerous. Nice issues have been constructed with every. However they do include a tradition.

A pair years in the past, I met an entrepreneur who selected to
construct his utility in Node.js. Curious, I requested why he selected Node.
The response was easy:
* sensible engineers are enthusiastic about it so I can extra simply recruit
* individuals are keen to contribute at no cost as a result of it builds their
expertise

This resolution clearly set the engineering tradition and outlined the crew of individuals
who may work or be fascinated with engaged on the challenge.

Asking a Totally different Query

So possibly as an alternative of asking what expertise I ought to use, we should always ask ourselves:

Does this expertise match my firm's core values?

That is a a lot tougher query as a result of it's essential truly perceive your
core values. That understanding is vital to constructing a profitable product.

You may't blindly copy a tech stack in the identical manner you may't copy a marketing strategy. It is part of your organization's id. Your core values, your goals, your crew and your
expectations are completely different.

The entire "it labored for X" argument is
not often legitimate. Look, Fb makes use of PHP, it "labored for them". Does that imply we should always all use PHP?

Expertise-Tradition Alignment

Characterizing communities is tough, however I will share with you the impressions and views that I've on numerous choices. Be at liberty to make use of the feedback to share your personal perspective and canopy different communities.

Previous Faculty

Listed here are a number of the "classics": languages which have been used for a
whereas and have confirmed their values. They're widespread, however do not encourage a lot ardour anymore.

Word: I omitted Perl as a result of I personally do not know any new startups constructing their core expertise in Perl (6?).

PHP

Philosophy:

• Get stuff finished, that is what issues


• It is like Primary for the Net


• So long as there's a technique to do it, it ain't damaged


• It really works and it is quick, the rest is pointless


• Do not be too educational, our language is accessible and anybody will be
  began very quickly. Attempt to do the identical factor with Java!


• Object orientation as an afterthought

Widespread use case: (as of mid-2013)

• Your first internet app


• Extending Wordpress/Drupal

Private opinion:

PHP had its days of glory. It actually made internet improvement simple and
accessible. Nonetheless, most likely because of the actually great amount of latest programmers who
began with PHP and a not so opinionated group, only a few individuals can
write good PHP.

Good idiomatic code examples are exhausting to search out and I am not even certain there may be resembling as idiomatic PHP. The result's a group recognized for poor code high quality, lack of
checks, safety nightmares and an after style of the early 2000s.

Robust PHP groups with effectively established conventions, processes and tips can accomplish nice issues,
however such groups are uncommon.

Java

Philosophy:

• Portability


• The facility & efficiency of C/C++ however with automated reminiscence administration


• Cares quite a bit about object-orientation


• IDE required


• Reminiscence is affordable so we devour it ALL


• Threading is the best way to go!


• Do not point out Java applets


• Have a look at my fairly JVM!


• Open supply (however owned by Oracle)


• Slower however safer improvement cycles

Private Opinion:

Java is kind of fascinating. A couple of years in the past a number of builders bought bored with Java and
explored different lands. They typically switched to interpreted languages
resembling PHP, Python, Ruby or extra esoteric languages like Erlang.

Nonetheless, Google through Android was capable of present that Java in itself is not as horrible
as we remembered (so long as you do not have to make use of J2EE or Swing).
There's additionally a "hipsterish" development that appears to point that Java is
truly cool once more. A number of that has to do with two issues:

• the JVM


• the unbelievable amount of top of the range libraries

That stated, for lots of us, writing Java all day lengthy does not sound
interesting. If you'll depend on the Java stack, there may be long list of other JVM languages
that are mature and play effectively with Java
libs (i.e: Scala, Groovy, JRuby, Clojure).
You may at all times to combine and match.

Hiring Java builders is not too exhausting since most college students popping out of faculty discovered Java,
however discovering nice early-stage startup engineers who wish to write Java is kind of difficult.

Facet be aware: If you're concentrating on Android, hold it easy, stick with the official
stack even in the event you may fancy one other JVM language higher.

There are nonetheless many causes to make use of Java's expertise in your new
startup, however you may additionally think about using a extra "fast/versatile" answer in parallel (Ruby,
Python, Node...). A multilingual surroundings brings a number of worth to
each the corporate and the engineers, which is one thing the Java
group appears to be slowly however certainly discovering.

Java primarily attracts extra classically skilled engineers on the lookout for
comfy, repetitive, well-known patterns. They are going to be used to the language, its
instruments and its pure rhythm. They won't be essentially the most curious
builders however they're dependable (in the event you choose the proper ones clearly).

C#/.NET

Philosophy:

• A greater Java


• Initially designed for desktop and embedded apps


• We now have a greater IDE than the Java guys


• We're enterprise severe however we are able to give you most of Rails' cool
  options


• We now have a conflicted imaginative and prescient of Open Supply


• Slower however safer improvement cycles

Private Opinion:

I went again and checked out C# when C# 5 was launched and I've to say
that I used to be actually impressed by a number of the new language options. From a
purely language design perspective, C# is kind of a bit forward of Java. I used to be
additionally shocked by how nice it was to write down Javascript in Visible
Studio (I actually did not anticipate that since my expertise with VS was
primarily round C++).

One other factor that actually impressed me: the standard degree of the
out there documentation is excellent!
However the truth that C# is not open supply, that Visible Studio + MSDN is so costly and
the entire surroundings reeks of licenses and prices, is little bit of a flip off.

Microsoft is slowly opening as much as open supply and extra open options like Azure. However as a
group, .NET remains to be fairly Microsoft-centered.
As a startup entrepreneur, you need to contemplate how you are feeling about open supply vs enterprise backed cultures.

C# primarily attracts a variant of the Java crowd: engineers searching for stability and a help contract over open supply. And so they can tolerate IIS!

Established Options

Through the years, two dynamic languages turned cherished by startups:
Python and Ruby. The 2 languages are
truly fairly comparable. These days Python is kind of widespread for backend apps
(NLP, biotech, APIs, SOA components) whereas Ruby is extra widespread for
consumer-facing apps.
Each of those languages endure from the identical limitations (primarily
efficiency and concurrency) however their core
values and communities have completely different focuses.

Python

Philosophy:

• Just one apparent technique to do issues


• Code must be stunning, easy and express


• Documentation is essential


• Robust language design management

Private Opinion:

As somebody who selected Ruby over Python, I typically envy the standard of
the documentation you discover in Python tasks.
I even have a love/hate relationship with the truth that Python is
designed to provide you only one proper manner. That is
typically nice for groups, however it may also be irritating.

In some areas, Python has a number of the finest libraries on the market, and
relying on the issues you might be tackling, Python is perhaps the proper
selection. Python builders know the way to talk about their code. They doc what they do
and are course of oriented whereas being pragmatic about their
approaches.

However Python was created manner earlier than the web turned
widespread and if concurrency and excessive throughput is a priority for you, a
dynamic, interpreted language with poor concurrency may not be the proper selection.

Python primarily attracts extra pragmatic, skilled, full-stack builders
wanting a contemporary however well-proven language.

Ruby/Ruby on Rails

Philosphy:

• Designed for people, not machines


• Excessive flexibility: in the event you mess up, it is on you


• Every part must be simple, elegant and enjoyable


• DSL on prime of DSLs on prime of DSLs


• Testing is essential


• Issues transfer shortly, be taught to maintain up


• Passionate and vibrant group

Private opinion:

So far as I am involved, Ruby has been my go-to language for years.
You'll find an unbelievable, typically overwhelming quantity of Ruby open
supply code. Rails is absolutely a tremendous internet framework making most internet
tasks simple to implement if you know the way to make use of the device.

However the flexibility and fast improvement cycle even have
downsides. Be prepared to take a position a big chunk of your time holding your code
base updated and migrating away from deserted libraries.
If you cannot depend on caching, the throughput of a profitable app will typically be restricted
by the dearth of excellent concurrency help.

Ruby builders are primarily Rails builders and an incredible majority may
have a tough time having the ability to determine core language options versus
framework options. They're typically curious, opportunistic (in a great way),
considerably pragmatic and care about code high quality/construction and
take a look at protection. Rails builders are sometimes early adopters as a consequence of
the truth that the framework itself makes use of some new applied sciences by
default (coffeescript, turbolinks, CSS pre-processors...).

Ruby and Rails primarily appeal to builders desirous to get issues finished
shortly however elegantly. These builders are sometimes
product-oriented and care extra concerning the function and buyer worth than the lower-level computational particulars.

New Gamers

These are the languages/applied sciences that get individuals excited. They
characterize the brand new wave of programming languages designed to run
in "the cloud".

Node.js (Javascript)

Node.js is not a programming language however it's the most well-liked technique to
run JS server facet. The identical manner most of my feedback about Ruby have been
about Rails, I will give attention to Node greater than JS itself.

Philosophy:

• Designed for real-time pushed apps with excessive throughput, low latency


• DIY


• Small core, the remainder is as much as the group


• Coupling is a sin


• Discovered classes from Ruby/Python

Private Opinion:

I discover Node.js fascinating. Technically there is not a lot new with Node. Python has
Twister/Twisted, Ruby has EventMachine, and C had libevent.

Occasion-driven frameworks have
been used for some time however Node has two main benefits:
* most JS libs are non-blocking
* most internet builders have to write down some JS anyway

The concept of utilizing the identical
programming language each within the entrance finish and the again finish appeals to many, however the worth remains to be unproven.

Node affords nice throughput (so long as you keep on with IO operations),
is straightforward to get began, and is enjoyable to write down.

As a result of nature of event-based programming, debugging and testing is difficult. Coping with callbacks will be upkeep hell. I hope that Node will undertake an official future/promise answer. And documentation is often spotty making leaping on an current challenge tough.

Node builders are positively early adopters and cozy making a customized construction/sample moderately than following conference.It attracts builders wanting to make use of a recognized language (JS)
to deal with excessive ranges of concurrency. Node as a framework is decrease degree than the classical MVCs which is a plus for hackers. Node builders additionally actually like the thought of utilizing the identical programming language on each server and consumer.

Clojure

Philosophy:

• A practical and fashionable Lisp


• Every part is knowledge


• Concurrency, concurrency, concurrency


• States are evil


• Nice Java interoperability


• A bit on the tutorial facet, however nonetheless being pragmatic

Private Opinion:

What I like essentially the most about Clojure is the lisp
spirit.
When you get previous the parenthesis and the operator/argument order,
Clojure challenges you to thoroughly rethink the best way you architect your code.
It is actually good and environment friendly at processing knowledge and pushes you to maintain
your code brief.

My drawback with Clojure is that I am not sensible sufficient to write down a number of
it. My mind shortly stack overflows attempting to observe the info.
Exceptions are sometimes meaningless and attempting to debug another person's code is
difficult for the reason that language itself is complicated and it may be prolonged
by macros. Lastly, the Clojure group is not actually web-oriented,
many of the work finished in Clojure appears to be data-centric.

Clojure primarily attracts extra fringe, language-curious, data-oriented programmers. If you're on the lookout for knowledge scientists with a programming language fetish,
Clojure is an effective technique to appeal to them.

Scala

Philosophy:

• Have the perfect of each object oriented and practical programming worlds


• Let the compiler do a number of the give you the results you want


• Concurrency issues


• Much less ceremony than Java, however aiming for similar or higher efficiency


• Reside in concord with the Java ecosystem

Private Opinion:

Scala is presently my language of selection when concentrating on the JVM. The educational curve is steep. Understanding
when to make use of FP vs OOP will be difficult and so is coping with the
language syntax itself.

That stated, getting the advantages of utilizing FP, whereas
nonetheless holding OOP when wanted, could be very helpful.
When you "get" the language idioms, writing Scala is definitely nice
and the group is kind of good.

The Play
framework is absolutely good and affords various to Rails,
particularly for API improvement. Twitter's engineering crew affords a number of sources and open supply code.

Utilizing Scala is a reasonably protected wager at this level. Java builders really feel
confortable and get to strive a extra "fashionable" language. Dynamic
language builders do not feel too removed from residence however get the Java
ecosystem, the efficiency enhance, concurrency and immutability.
The tooling and convetions make utilizing Scala on a
rising crew fairly good, if the compilation time does not get you down.

Like Ruby, although, the Scala group is not large on documentation.
I actually hope the API doc might be rewritten to be extra intuitive and general extra helpful.
However to be honest there are a number of nice sources on the market resembling
Twitter's Scala school and
Coursera's FP in Scala class given
by Martin Odersky (Scala's creator).

Scala primarily attracts curious Java builders wanting
one thing extra fashionable in addition to Ruby/Python builders wanting a extra scalable model of their language.
Scala is an effective technique to appeal to nice builders who wish to push
the boundaries of their current dev surroundings in addition to builders having the ability to leverage the duality of the language.

Go

• A greater C


• Reminiscence administration is dealt with for you, however do not be wreckless


• Express is best than implicit


• Wealthy built-in performance


• Quick.. every thing (from compilation to execution)


• Concurrency built-in and made simple


• Documentation is essential

Private Opinion:

I actually like Go (aka Golang). After taking part in with it for years, I selected to make use of it to
develop the APIs of my very own startup. Go may sound boring to some, however
its simplicity and effectivity simply work.

Go forces you to assume a bit extra about the way you construction your
knowledge/conduct as a result of you may't simply keep on with the same old OO patterns. I've discovered that my code finally ends up being simpler
to observe and easier in construction, but typically a bit extra repetitive (ex: error dealing with).

Concurrency cannot get a lot simpler than Go. Whereas it's compiled, your code compiles and boots in much less time than a Rails server begins up. Go helps some type of duck typing making the transition from Ruby (for example) fairly simple. The manufacturing efficiency is kind of superb when coming from
a scripting language and the reminiscence footprint stays small.

Go is designed so a single consumer or a giant crew can work on the identical codebase and the tooling across the language is absolutely nice.

Nonetheless, it isn't an ideal language. third celebration dependency administration will be difficult at
occasions. The code can really feel too low-level once you're used to high-level programming languages. And a number of the language design choices may cause confusion at occasions (ex: interacting with interfaces vs structs).

Go appears to turn out to be fairly widespread throughout the startup scene when
efficiency and concurrency issues. I've seen variety of startups migrating from Node to Go and others merely extending their stack by including small Go apps.

The Go group appears to be a mixture of old style hackers coming from C/C++ and a youthful crowd having fun with a lower-level language.
The language and the group leaders are opinionated which makes
understanding their imaginative and prescient and method simple. It additionally permits you to
shortly consider how comfy you might be with their philosophy and see if it matches your expectations.

Go primarily attracts efficiency/structure oriented builders.
They need simple concurrency, the execution velocity of C with the event velocity of
Python/Ruby. They do not search for a brand new enjoyable language, they search for a
strong compromise.

Expertise Drives Tradition

Technical choices have cultural impression. Suppose clearly and thoroughly about how your applied sciences align together with your firm's core values. Make the proper decisions and you will spend much less time preventing about technical particulars and extra time constructing an incredible enterprise.

And in the event you miss these arguments, there's at all times hackernews.

---

Replace: Talking of HN, here is the thread for this post