So, what are the programming languages/frameworks of the future?

Moore's Law is dead. ASM will make a comeback.

Lisp ;__;

Compilers will use deep neutral networks to produce better machine code, but there will always be a place for asm

Near future?

jaxenter.com/software-development-is-deteriorating-into-abstract-paradigms-and-cool-tools-122299.html

You can do almost all the optimization in C these days. What matters is knowing enough assembly to check if the compiler output was what you wanted and knowing enough compiler tricks to convince it to generate that assembly.

Lisp pleb. Scheme master race over here. Can't wait for it to take over and send lispbabbies crying

WebAssembly, abacuses and smoke signals, and then COBOL, in that order.

PHP

Don't forget punchcards on drum memory computers running Node.js

COBOL

Scheme is a Lisp you tremendous bundle of sticks.

It's a lisp-1 not a lisp-2 and objectively better in everyway

Don't you mean punch-the-monkey e-cards on dubstep computers?

Haxe

Enjoy being homeless mate, what are you going to do for a job when baristas are replaced by robots?

don't be so salty m8 - robots, stronk womyns, and shitskins are coming for your dev jobs, get over it.

For the next 10 years I predict the dominant languages will be

Python is easy to use and that counts for a lot. It will be used increasingly for teaching, science, data science, and all sorts of small projects.

With the advent of ES6, compile to JS languages like TypeScript will find it harder to compete. ES6 works just as well with Babel as transpiled languages, and soon will have native support. WebAssembly will also be a big boost to continued JS adoption.

Big tech companies, and major software projects like browsers, will continue to rely on the speed of C++.

Losers of the language wars include

Java still dominates in the enterprise market, with its unparalleled tooling, but it is under attack from C++ in performance intensive areas, and Python where flexible scripting is needed.

Too complicated for the average developer.

While technically superior to C++, it will lose out due to its reputation as microsoft specific, and the smaller number of libraries.

Braces are too hard to read, or at the very least their learning curve makes people think they are hard to read.

Looking 20 years ahead, I predict some kind of strongly typed language will emerge, either Haskell-like or with full dependent types. But first people will have to iron out the rough edges and produce user friendly syntax and tooling.

I am of similar opinion, although I'm not so sure on the Haskell part. It might be too purely functional. This can impede people who just want quick and dirty solutions.

This, this is why I don't hang out here much anymore.

Rust, the best combination of expressiveness, safety and speed.

you spelled 'worst' wrong you stupid fucking dipshit.

sorry that opinions different to your own are so triggering. I'm sure there's a subreddit out there for you user.

It's more of a meme than Haskell.

It's just too cringy to read some guy write a book when it's clear he has no idea what he's talking about.
If you really need some arguments:

Typescript's featureset has nothing in common with ES6's. ES6 does not bring anything new regarding types. You were thinking of Coffeescript's lambdas and classes I suppose.

C++ is a language that compiles to machine code. C# compiles to bytecode which is then executed by an interpreter. These languages have nothing in common except syntax similarities. You just did a "JavaScript == Java".

And let's not get started on the thoughtless banalities you spewed for the other langs.
Go back to studying and stop trying to predict what's going to happen in 10 years.

Typescript has inheritance and classes, which are also provided by ES6. These are important features.

I was thinking of Typescript's classes. Lambdas aren't a big deal.

I'm aware that TypeScript has type checking (I've even written some TypeScript), I just don't think it's enough to convince people to bother with it.

Just cause two languages are technically different doesn't mean that they can't be used for similar. Are you even aware that Java and C++ are often used for similar things, or that people go to great lengths to compare the performance of Java vs C++ for similar problems? C# is close enough to C++ that Microsoft tried converting a lot of its code to C#, failed and went back to C++, then moved back to C# when the C# runtime was fast enough.

C# is a cleaner, safer language than C++. This is not surprising since of all the big tech companies, Microsoft have the most programming language researchers. They also did a good job of Typescript in spite of what I said above (so good in fact that Google wrote Angular 2 in TypeScript).

No please, go ahead.

Why don't you try calming down?

Typescript classes and inheritance are the exact same as in ES6, backported into the language.

I can't even.

No, the reason is simple:

C++
C#

You've just described the current situation and called it a prediction.

Why don't you try shutting the fuck up.

Google will write projects in whatever language the one in charge of the project pleases. Appeal of authority isn't worth a damn here.

Yes, and that is going to make users less likely to bother with TypeScript since they already have that feature in ES6. Which was my point in the first place. You were the one who said

Rest of your points are just bickering, you're clearly an uptight cunt.

C# is nothing like C++ and shouldn't be compared to it. C# is Microsoft Java. 99% of the language was copypasted.

Functional programming will never take off because of one simple fact.
Most programmers are retarded and can't even program in imperative languages.

Why is JS so popular?
- Because it is easy

Why is Go gaining popularity?
- Because it LITERALLY was made for retards

Why is Java STILL popular?
- take a guess

u mad.

It seems that whenever Haskell is mentioned the automatic responses are "lol Haskell is a meme language" and "most people are to retarded to understand it".

So tell me this: why aren't we promoting using languages that dumb people can't use to chase dumb people away?

Very simple.

And that's just it. The current trend is making literally everyone into a low-level codemonkey so the salary of the average progammer will eventually approach what you earn for flipping burgers.

An interesting side effect of this is that we will have worse and worse code in the future which will lead to some real problems down the road.
It is all about the shekels.

XSLT

Ok just so you know, for your own education I guess, the only reason people - by that I mean relatively smart people, not you - bother with TypeScript is, you won't believe it, types.

Again, Classes and Inheritances aren't "Typescript features", they are "ES6 features" (or rather, syntactic sugar for already existing ES5 mechanisms but I'm assuming you know that already hm hm), incorporated into TypeScript for developer convenience, so these lazy bums don't have to transpile it themselves.

Nice straw man, followed by a beautiful ad hominem, we have a winner!

Definitively.

How does your comment address anything that has been said in ?

meant for

is spot on

Something with Hindi or Chinese tokens rather than the standard English function naming and control statements.

💩 🚽(💩)
{
नामित शौच सड़कों पर
}

Most code is written by hordes of idiots, fumbling around in google and stackoverflow. This is why companies in response hordes of systems and testing """engineers""" to keep their shit in check so they don't deliver a completely broken system - just a half broken one.

Sooner or later the copy/paste coder will be replaced with a slightly less dumb machine intelligence.

What's wrong with using stackiverflow and other projects on github etc to model your own project on so you don't reinvent the wheel.

Your phrased it in a negative light but what's the alternative?

Probably a non-lazy by default Haskell

Scala is already popular, but it's limited by the JVM

You will see popular languages are finally adding haskell features such as HKT, soon they will see what waste their syntax is doing

This already happens with C# and F#, on the things that achieve the same thing, F# is way easier to understand and doesn't get in your way

You can, but copy/pasting is considered a taboo for programmers, and I assume he is making a joke about people who go to these places being copy/pasters.

Really if you want to be a good programmer you need to read books or maybe take a class or two on the subject. But for hobby coders stackoverflow and the like are fine.

C

You're not wrong, but being an art major will make you even LESS employable than the devs you're laughing at.

It's like you niggers don't even know what art is. It's like people who learn philosophy in school.

Node.JS on rails

There's a difference between someone wanting to get a little help with implimenting something the first time and copy/pasing everything off of the Internet, the second group being the smallest.

This is, of course, only in legitimate comunities. Let's not forget the Node.JS string padding debacle where nobody in the community was competent enough to work with strings and just relied on some dude's 15LOC library to do it for them. He fucked up one day, pushed out a bad update and took out 2/3rds of all NodeJS on the market.

Unsage

Once again Holla Forums talking about things they have no idea about.

First pushing a bad update has very little chance to take out anything, when you specify a dependency with npm, you lock it at a specific version.

Second, that's just not what happened. The guy asked npm to delete all of his packages because of a different he had with them (TL;DR, the guy got upset after they hijacked one of his packages because it shared the name of a company and that company wanted it).

And third, JavaScript has no printf, so it is indeed a legitimate thing to do to use a premade function to pad a string instead of recoding it yourself, however trivial it might be.

everything will be coded in javascript

Jesus christ...

Scala is going native with LLVM, not limited by the JVM anymore.
scala-native.org/

Poolang

if (💩 in 🚽) { return;}else{ 🚽[💩] = [💩]; return 🚽;}

A nice touch.

C#, Javascript, whatever androids sdk is called, MIT scratch, and the first programming language based on the linguistics of hindi.

I don't get why people think functional languages are hard.
Haskell is not that much harder than Python.

You vastly underestimate how stupid people are.

True, but you can complicate Haskell more than necessary with lots of theory that throws people off. More so than any other language I would argue.

No, on the contrary, the same complicated concepts will look simpler in Haskell than in other languages, and that's precisely why people tend to do it more often (and also because the whole culture around the language fosters research and experimentation).

PFFFFFFFFFFFFFFFFFFFFT

I don't disagree, but I was thinking more of bringing in category theory when learning out the language.

Well, the languages of the enterprise will continue to be the lowest common denominator imperative OO garbage, Java, C#, etc.

The language that I will be using, at least, will be some lisp like language with a type system based on homotopy. Dependant types are amazing, Idris being the best example I've seen thus far. Haskell like languages with good type systems, Lisp like languages with good syntax, and Forth like languages with good performance are the best in their respective fields.

Despite all the fanboys, C is garbage, so fortunately it's on the way out. The unfortunate fact is that the vestiges of C will probably haunt us forever because so much effort has been spent on making optimized compilers for it, and so many legacy systems and low level systems are based on it.

Are you referring to Homotopy Type Theory (HoTT)? I never managed to get my head around what the univalence axiom meant, or how it would be useful for programmers.

Also knowing asm helps with debugging

When will we have a C framework for the server-side that's popular enough?

So, what are your opinions on Go lang?

Go create a Golang thread if you want to hear /tech's opinions on it. It is not a good language. It has the performance of Java with the autism of C. Bad combination.

I didn't think it deserved another thread.
Also, i didn't think it was that bad, people said that it was a PHP done right, but i guess they were wrong.

Never. webdev shit is purely written by terrible - and often outsourced - programmers like Josh that you can't trust to write safe code. It's more economical to use 10x the hardware for an implementation in a pointer-safe language if you can pay your labor a tenth of what it'd cost to hire good C programmers.

Don't get mad about it or try to fix it, though. You WANT webdev to be containment. Don't invite streetshitters into low-level / systems development. Put up barriers to entry, don't tear them down.

C++. Seriously.

Bingo.

Say you have some data structure (x, (y, z)), that is, a struct containing some other struct, or a pair of pairs, and you write a bunch of functions to manipulate that data type. Then, someone else has a ((x, y), z) type, and some more functions on that type. Univalence lets you transport the functions from one type to the other, so any code that used the first type can manipulate data of the second type, without any work writing translators. This is like views in the couple languages that support the concept, but better because univalence takes care of the conversions and other plumbing.

For a more concrete example involving optimizations, assume you have a sequence type (Seq a), with an implementations (List a) and (Array a), and operation map (a -> b) -> (Seq a) -> (Seq b). Since map (g . f) is equal/equivalent to map g . map f, the compiler can transform two pass mappings into one pass mappings. This is common in e.g. C compilers, where two for loops over the same data will have their bodies combined(so-called loop fusion). Furthermore, since (List a) and (Array a) are both equivalent, you can write easy to understand code using List, and your code can be transported across that equivalence to Array. This particular example is common to pretty much every compiler, but if you have similar equivalences for your own types(say, that operations with the ((x, y), z) type are faster), then those transports can be used freely by the compiler as well, without the programmer having to worry about any implementation-specific details of the conversion.

Dependant types also allow for very fine-grained proof types, for instance, you can require that all implementations of append on two sequences with length m and n produce a sequence of length m+n. In a more complex case, you can require that all memory allocations are freed before a program exits, or that a sorted set is correctly sorted, or that there are no infinite loops in your algorithm, or that there is some upper bound on the time taken to run some algorithm.

cs.ru.nl/~freek/courses/tt-2013/hott/dijkstra.pdf

Because people using high level languages really want to drop down to the autistic shitfest of "muh C" and seppels right?
t. professional haskeller

This language looks pretty interesting .

crystal-lang.org/

.NET stack, JS. As it is now.

Good joke, user.

nice post quoting skills

But user, the best systems development languages are Haskell and Lisp. Look at Genera and seL4(and seriously, use seL4 as your OS if you can).

fuck off CIA niggers

Thanks, I'll take a look. I suspected univalence might have this kind of practical application, but I've never seen a demonstration.

actually I think I already understand the general idea: If I had accidentally written a proof with one algebraic data type, e.g. List, and then I end up with an equivalent data type like (n ** Vect n), then univalence will convert my proof for lists to a proof for my new data type. But without univalence I would have to manually rewrite my proof for the new data type.

In fact even if I used List2 instead of List where List2 was defined exactly the same as List, I would still have to rewrite my proof if I didn't have univalence.

you might also like

people.cs.kuleuven.be/~jesper.cockx/Without-K/Pattern-matching-without-K.pdf

HolyC

Functional Programming, definitely.
Probably Scala. Maybe Haskell and Clojure as well.

I also think Python will be more common as western nations start to bring mandatory programming classes into schools.

seL4 is written in C. The Haskell stuff was just part of their 'proving' it secure and correct.
This may have involved also implementing it in Haskell, I'm not sure, but the finished product is in C.

You're right. They wrote a working version in Haskell and defined this to be the specification of the kernel. Then they rewrote it in C and used an automated proof checker (Coq?) to prove that the C version did the same thing as the Haskell version.

unsage

Hopefully robust first computing becomes a thing, spreading computation across many computers with redundancy at every level.

The implementation of that will probably be functional, because the only network I can imagine programming on is CAS like IPFS, though some mad wizards might figure out another way.

Definitely Visual Basic 6.

Since I avoid programming concepts younger than myself that's not really an advantage.

The concept of functional programming is utterly useless for non trivial concurrency (ie. not the stuff Haskell programmers love). There is nothing functional about Erlang's concurrent features for instance.

I'm still hoping Adobe will fucking open-source CF. It's a shame to see CFML dying, but at the same time, it also ensures I'll have a well-paying job for the rest of my life, even if I am constantly fired for whatever reason. (not that I ever would be)

Then again, OpenBD can always just be updated and take charge of CFML, rather than just hoping Adobe will do anything of actual value. That requires me to get off my ass to learn Java, though.

Let's not forget that they restored it, even against his wishes for it to have been deleted. I hope they get bit in the ass for doing so.

Do you realize how young programming is as a field? Even if you were 13 years old that's a stupid thing to say.

FOR WHAT FUCKING PURPOSE

csc.villanova.edu/~japaridz/CL/

Lower wages even more. Swarming us with subhumans is still not enough.

No one has mentioned it yet, but I think we'll move more into 2D and 3D graphical programming environments.

Imagine being in a VR simulator connecting streams of various prefab core components together.

sounds tedious as fuck, fam

Clojure would like to have a word.

tbh, most of these students still won't be programmers. We'll have an increase in programmers, but the vast majority of them will never touch it again. Maybe the smarter ones will use it to make their office job easier.

When you have processes (agents, actors, whatever) with internal state passing messages around, like in Erlang and Clojure, I don't think calling that functional is justified.

Isn't clojure only semi-popular because people stuck in the Java dumpster are desperate to find a way to avoid the Buckley-level of wordswordswords? No one allowed to use non-JVM languages seems to give a shit about LISP other than undergrads.