These are the three most cancerous mainstream programming languages in history...

worth noting is that JS is in a completely different league of bullshit nonsense than the other two

integers? nah
checking if number of passed arguments match function arity? nah fill it with undefined

there's a reason things like coffeescript exist

>checking if number of passed arguments match function arity? nah fill it with undefined
taking variable number of arguments in a function and letting you access them as a list is a feature that most all

I kinda enjoy php, learnt it out of necessity from dealing with wordpress
t. not a codefag

I feel like this board shit talks other languages more than actual programming.

php is a great starter language that allows for most things, and is pretty vocal about what's wrong, where and usually also why.

From an experienced perspective it has a few too many issues to be a modern language though

Personally I am more a fan of Scheme and Clojure than CL, but somehow I doubt you have even the slightest clue about what's going on the picture you posted..

(defn factorial
([n] (factorial n 1))
([n f]
(if (

>I doubt you have even the slightest clue about what's going on the picture you posted..
I wish I didn't. This language's syntax is about as bad as Forth's, and that's saying something.
In terms of capability it's perfectly fine, but that syntax. Why.

You mean CL or Lisp generally?

CL is somehow the "C++ of Lisps", it has many features and incredible powers, but it's not really the definition of a small language. And it's unhygienic.

> but somehow I doubt you have even the slightest clue about what's going on the picture you posted..
no, I think the person you quoted has perfect understanding of the code in the pic and so do I

over-using recursion as a drop-in replacement for looping is retarded. recursion is more error prone, it usually has to be optimized with variables holding state, it requires mental memory of state on the stack, really stupid unzipping and re-zipping of variables onto lists

any half way intelligent person is going to use mapping functions or iterate over ranges. recursion is just mental masterbation

>over-using recursion

Oh boy, here we go..

I don't think you understood the point of tail recursion. For a compiler (that can into tail recursion) it's basically the same as an variable.

And state look fine at the beginning, but for many problems (i.e. concurrency) it's pandora's box. Languages like Python or Ruby do have an global interpreter lock here, not beacause the developers were stupid, but because you can get into ugly shit here.
And languages like Erlang who is king when it comes to concurrency does use what? Immutable values.

The whole functional paradigm is all about avoiding state - or reducing/isolating it as much as possible. Clojure has very clear and clever principles when it comes to state management.

wow, you litterally said nothing but spout kool-aid FP bullshit you read on blog posts

you dont need recursion to handle immutable variables dumb fuck

Attached: (you).png (707x530, 71K)

what language is the horse one?

ok, let me spell it out to you so there is no doubt that I do know what Im talking about and you dont

when you use mapping functions or iterator functions over ranges, you are not mutating variables at all, in fact you never explicitly use variables or half to keep track of passing variables into the right recursive function. Variables are manipulated implicitly in mapping functions and so mapping/reduce/iterator functions should ALWAYS be used instead of recursion and can be used instead of recursion in ALL cases. Recursion offers nothing over iterator functions but rather requires use of stateful variables to be used in tail-recursion for optimization

>over-using recursion as a drop-in replacement for looping is retarded

That's a typical "baby duck syndrome" answer.
You could also say "using meaningless auxiliary variables instead of proper recursion is retarded"..

If you look closely any iterator does nothing more than visiting each element - tha same thing you naturally do when recurring with "car" and "cdr"..

Also recursion makes may things very logical and sharpens your logic.

Just one example:
Adding is simply a repetitve application of the increment operator.
Multiplying is simply a repetitve application of the plus operator.
Exponentiation is simply a application of multiplying.

This may sound silly, but the point is that you only need very few operations to actually make complex structures. The original Lisp had.. I'm now sure, but about 7 or 8 keywords and could build literally everything from that. That's how far you can get if you have powerfull, orthogonal language constructs.

Lisp is not the be-all-end-all language, but it's a great thing to learn and still blows many contemporary langauges out of the water.

See:

To elaborate on this..

Here is how easy you can make an array access out of a list:

(define (pick n lat)
(if (zero? n) (car lat) (pick (- n 1) (cdr lat))))

It is not so differnt form a for-loop really.

Or here is a simple "reduce"-function..
(define (addtup tup)
(if (null? tup) 0 (+ (car tup) (addtup (cdr tup)))))

..or "filter":
(define (my-filter e li)
(cond
((null? li) '())
((eq? e (car lat)) (my-filter (cdr lat)))
(else (cons (car li) (my-filter (cdr li)) ) ))))

It's simple, isn't it?

And not make map/reduce in C:

You need:
- constant boundary checking (since you have no terminator element in lists, only in strings)
- one needless variable
- test this variable
- raise this variable
- manually set the entry to the next node of the list to the element you have filtered..

..meh.

perl, a garbage scripting language
for future reference, it's a horse, not a camel

Yes.
We should just improve BASIC instead.

>To elaborate on this..

>Here is how easy you can make an array access out of a list:

(define (pick n lat)
(if (zero? n) (car lat) (pick (- n 1) (cdr lat))))

The fact that you use that as an example of 'easy' recursion shows just how far people buy into the hype of FP and really dont know what the fuck they are doing. The example you use requires passing an explicit iterator variable (the whole point of using recursion is to avoid keeping track of variable state) and then you have to statefully decrement that variable for your recursion to work (again, the whole reason to use recursion instead of for/while loops is to get rid of manually tracking variable values). Youre a fucking idiot for using a recursive function like that for anything, ever.

I like how name-calling is the foundation of argumentation in this pic. Fag

>doesn't even post the correct version
That's what one would expect of a lisp fizzbuzzer. Poset of programming languages is Coq > Haskell > OCaml > Lisp > the rest.

Attached: arguments1.jpg (777x656, 119K)

when you piece of shit lang achieve this oneliner and still keep it readable you can talk

const a = [1,2,3].map(i => i * max ).reduce((acc, i ) => acc + i , 0)

Why C++ and no Java

I no understamp

>C++
Because James Gosling is a asshole

40 years of technical debt (C preprocessor, exceptions, new/delete, etc.)
idiomatic ideas have complicated syntax whereas deprecated ideas have easy syntax
generics implementation is turing-complete

So then what languages are non cancerous?

Is that complement for me or for the BSD asshats?

c#
swift
python
haskell
r
[spoiler]rust[/spoiler]

youtu.be/MticYPfFRp8

None

>Why C++ and no Java
Java isn't terrible, it's just dumb and occasionally frustrating. I personally try and avoid it, but I can't think of any Java program that would be significantly better if the developers had picked a different language.

I autistically thank you

Minecraft?

Minecraft would still be badly designed if it was written in a different language - almost all of its flaws are because of Notch, not Java. If anything, using a GC'd language may have limited how bad it could be.

theres a half dozen clones written in a handful of languages and they're all caught up to notchcraft by now.

C++ is varying levels of okay. Better in the past few years. Older C++ was always the worst, not better.

What's wrong with ocaml?

there's nothing wrong with it, it's just rust has been made which is superior

>Older C++ was always the worst, not better.
;'c
Well you try coding a fucking revolutionary programming language

What does rust have to do with ocaml

The problem was the 20 years before it had a standard and EVERYONE tried making that revolutionary programming language at once. Much of this is forced into backwards compatibility stuff.

>theres a half dozen clones written in a handful of languages and they're all caught up to notchcraft by now.
Sure, but I don't think that has much to do with the languages they're using.

So you're saying it's not my fault?

It's always the Danes' fault.

That's all I ever wanted to hear c:

It took all the good features of ocaml and adopted them in the worst possible way, but left out the greatest feature of ocaml, and the sole reason that it still isn't irrelevant - modules, because apparently it's too hard.
Rust is terrible language, to the point that C++ (yes even the abomination that it isin many projects) is a much better choice.

>Rust is terrible language, to the point that C++ (yes even the abomination that it isin many projects) is a much better choice.
explain this

should be Java, COBOL, C#

How are exceptions technical debt? They're pretty much mandatory in any modern programming language so you don't have error handling (unexpected, exceptional errors) clogging up functions who are unable to deal with the error locally ("if err != nil" comes to mind).

Soft-realtime is the only area where rust has any chance since nobody in their right mind would bother writing a high-level system in unmanaged language (also Haskell, F# and OCaml exist if you want an actually useful type system).
In 2018, you're competing with C++17 which is a good language and rust is only marginally more expressive, but somehow even less readable than template abuse in C++. On top of that, you lose the killer feature of rust for this area - memory safety, because your code will be sprinkled with unsafe (and guess which code your hot path will go through the most). Summa summarum C++ with coverity will lead to comparably safe code in perhaps slightly less time, but it will be easier to read, maintain and extend which should be your concern.
Rustfags are always pathetically bringing up the safety, but real rust code is never there. The best attempt at safety was seL4 and those guys did, and continue to do an amazing job. In C, because when you *actually* care about safety, you can choose between Ada/SPARK and C.

The camel is perl you mongotard lol

Optional and monads will be the way of the future allowing you to chain together operations without having to check each intermediate step for null and errors

Rust was created by an OCaml guy and the first compiler for it was made in OCaml

>C++ is a better choice
How could anything designed from the ground up in modern times fail this hard? C++ was just C with class and just kept throwing in a new kitchen sink everytime something new came around. C++ fags couldnt design their own language so they just mixed them all together hoping they can hang on to relevance.

>Perl
>bad
This language's reputation is mainly a result of the developer culture surrounding it, not the language itself. It is a great choice for the tasks it is meant for, and Wall's background as a linguist translated into some fantastic design ideas. Structured, clean code is perfectly possible in it. Instead, people kept using it for various things it is poorly suited for because the modern alternatives like Python weren't viable yet, and thought writing programs as line noise was funny and acceptable, because can = should.
It is still ubiquitous as a Unix language for a reason, even if autists insist that shell scripting is perfect for everything that doesn't warrant C. I still use it sometimes when data processing in a language like Python is too clunky.

Interesting. Know any useful sources on OCaml?

Probably real world ocaml but nowadays there are languages that have mostly replaced it like haskell or f# which I think is considered a subset of ocaml.

Haskell is what I'm trying to avoid, honestly. Functional purity and lazy evaluation by default are overrated.

Perl was the first scripting language. Before Perl there were only shell languages. Perl is the first language with built-in string processing functions

>perl
>cancerous
wrong

Attached: 1520567304363.png (852x854, 1.14M)

>perl
In numbers it probably didn't even cause a dent, unless you count its influence on other scripting shit or the fact that people want scripting shit to program.

sure, REXX, awk and other things are pure fiction

eh? in the 90s pretty much all CGI was done in perl

in this thread

hipsters who write todo-list apps in pissant languages

Which wasn't so bad, believe it or not. CGI and networking are some of Perl's strong points.

And it was basically gone before internet usage became influencial enough to make it matter.

not suggesting it was bad, just correcting the commentor

starsoup did nothing wrong

There is nothing wrong with Perl5.

>it's a horse, not a camel
you got those swapped

you were wrong, though
Unless you consider Perl as the father of PHP.

JS has some issues, but it has helped to bring some nice concepts into widespread use among high-level programmers: closures, associative arrays as the primary type, arrays as a special case of associative arrays, object factories (and prototypes if you need performance) instead of classes, variadic functions, etc.

what's wrong with lisp, are you retarded user?

It's not the languages that are cancer themselves, user, it's the users.

Well those arent really general purpose languages like perl. For what perl is, a shell language, its the best. But thats where it should be left at small shell scripts.

> using pleb non-array oriented languages
+/max*1 2 3

Saing that Forth syntax is bad is a blasphemy