Any decent modern general-purpose languages?

Assembly: Unportable. No standardised syntax.
Classical Visual Basic: Some good parts. Shit overall.
C: Shitty standard library. Deficient type system. Can't into Unicode. ``Unportable assembly.''
D and C++: Obfuscated boilerplate languages.
Java and C#: Forced OOP.
Common Lisp: Archaic cons-based library. Writing complex macros is a PitA due to the unlispy quotation syntaxes.
Scheme: CL without namespaces.
Clojure and Erlang: Concurrency is unneeded outside of a few very specific applications. Parallelism is where it's at.
OCaml: Great language, only one, deficient, implementation.
Haskell: Academic sex toy.
Forth: Reinventing the wheel over and over.
Ruby: Implicit declarations. Slow as fuck.
Python: Implicit declarations. FioC.
Perl: Brain damage.
PHP: Pretty much shit.
JavaScript: "" == false

It's impossible to list them all but, please, what decent modern general-purpose languages exist?

Lisp and assembly.

Try Lua I guess?

Prolog: Perhaps the slowest programming language on the planet.

C is too old, and its semantics were built on 1970s instruction sets. We need a language as close to the metal as C with modern design, but not going overboard with the shitty hacks like SEPPLES.

>>5
>>2

Python + Cython

Performance, elegance, portability.

>>7
Enjoy your half baked lambda implementation.

>>7
FIOC is not elegant.

Go.
Statically typed, duck typing, no shitty OOP without sacrificing usability, simple, easy to write, looks good, compiled, quite fast, garbage collected, good library, easy to FFI with C, great concurrency, no boilerplate or garbage syntax, easy (and fast) compilation without the need to write Makefiles, ...

>>8
You can use everything except statements in Python's lambda. Python can be fully functional (in both meanings) with only expressions.
If you really want to use statements so much, just use a closure. Functions are first class objects, lambda is not really necessary.

>>11
What's a closure?

Sorry, I'm a complete functional fagstorm.

>>12
I was talking about defining a function inside another function and then returning it.
This inner function has access to the scope of the outer function, so you can do something like this:
def a(b):
    def c(d):
        return b + d
    return c

f = a(3)
print f(2) # 5
print f(3) # 6
g = a(6)
print g(2) # 8
print f(2) # still 5
As you can see, the inner function closes over the variables in the outer one, thus ``closure''.

Basically, anything you could do with a lambda, you can also do with a standard function.

>>10
package/import aren't elegant.

easy to FFI with C
What isn't?

Factor.

>>14
Why aren't they elegant? Packages are useful for organization and what would you use instead of import?

Many languages have FFI, I didn't say Go is special. However, there are several languages where that isn't really simple to do. Go isn't among them.

>>1
lol general purpose languages.

java is about as general purpose as it gets, it has the worst of pretty much every paradigm.

(or you could like, pick your language based on your task like everyone else)

>>13
So a closure is a nested function? Does that mean GNU C has closures?

Damn.

Thanks, >>13-san.

>>18
http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html

GCC implements taking the address of a nested function using a technique called trampolines. This technique was described in Lexical Closures for C++ (Thomas M. Breuel, USENIX C++ Conference Proceedings, October 17-21, 1988).

yes apparently

>>5
totally agree, C and C++'s day is over as general purpose programming language, they will be relegated to systems/embedded programming which they were meant for. Languages like D, Go and Rust are the future

>>1
fuck you for thinking javascript is shit. you're obviously not worthy of calling yourself a programmer

>>20
D, Go
GC is shit

Rust
not ready yet

1-22
languages
terrible

>>20
Languages like D, Go and Rust are the future
That's funny because they are all terribly useless. Absolutely no one uses them in production, for good reason. Go is a shit language; it's like C mixed with Javascript and Pascal, but crippled. Google doesn't even use it for anything important. The only reason anyone has heard of it is because of cat-v Plan 9 faggots astroturfing on the web. Rust and D are even more obscure and shitty. D is like C++ except for retards. Not to mention that none of these have compilers that produce code as fast as C++ compilers, or even the JVM for that matter.

D is like C++ except for retards

lol'd

have an upboat

>>24
Go is hardly useless. It it enough like C to feel familiar while not bothering to implement features irrelevant to modern programming. That makes it simple to program with (unlike stuf like C++) without any major drawbacks (such as Java's forced OOP or scripting languages' inability to do any lower level stuff, not to mention their egregiously slow speed). Go sources are usually more portable than your standard C or C++ code too.

For example, the lack of pointer arithmetic and manual memory management means that the programmer has a lot less stuff to worry about.

In addition to removing completely unnecessary (and outright dangerous) features, Go is also quite strict. You mustn't have unused variables, code style is enforced, no implicit type casting (including int and int32, despite being the same underneath, being separate and requiring explicit casting), etc. While that may seem to be excessively restrictive to your standard volatile C obfuctor, it inevitably results in a code that is generally cleaner, safer and better.

Garbage collection should be the norm in userland applications anyway, because the tiny amount of speed gained by manual memory management is utterly negligible in all but the most performance-critical code, while it makes segfaults and memory leaks all but gone (yes, >>22, GC is actually useful).

In speed, it's true that Go is somewhat slower than C/C++, but that's only to be expected with GC, type reflection and other features. It still at least matches, if not outright exceeds, the (both programming and execution) speed of most equivalent Java programs.

Google stated that they use Go in several of their internal applications. In addition to that, Go is a good choice for Google App Engine.

Conclusively, Go is a true current-generation programming language that's focused on ease of use and good programs, not on any  irrelevant innovation that's ultimately destructive, since it precludes the good, simple and obvious ways of coding in order for the programmer to make use of the novelties.

>>26
Why is prague such a destination for viral marketers?

Perl. Haters gonna hate.

Truth is, if you have to ask "can i do _ with perl?" Answer is most likely yes.

>>28
Can I write uniform-looking and easily-readable code (from the perspective of someone who's not a Perl wizard) that also executes fast enough (Java-tier speed, not Python-tier) with Perl?

>>28
can i write a function that accepts two arrays as arguments?

>>27
It's the same reason why there are trolls and shitposters who disparage others senselessly.

>>28
Can I reify part of the continuation up to a certain prompt contained inside of a continuation mark as a procedure and call it multiple times?

>>13
>Basically, anything you could do with a lambda, you can also do with a standard function.

Except for the fact the closures won't have the same state unless the variables are immutable.

>>33
If you change a variable afterwards, that's your fault.
Don't do it if you don't want that.

>>34
Which defeats the purpose of emulating closures in the first place.

And just for the record, java requires variable to be final when emulating certain types of closures.

Every programming language is crap unless it's Lisp, which is shit.

Programming is a disgusting practice and you should be ashamed.

>>24
That's funny because they are all terribly useless. Absolutely no one uses them in production, for good reason. Go is a shit language; it's like C mixed with Javascript and Pascal, but crippled. Google doesn't even use it for anything important. The only reason anyone has heard of it is because of cat-v Plan 9 faggots astroturfing on the web. Rust and D are even more obscure and shitty. D is like C++ except for retards. Not to mention that none of these have compilers that produce code as fast as C++ compilers, or even the JVM for that matter.

Languages like C and C++ had their day in the 80s when you had to write directly to hardware on singletasking OSless home computers. When you wrote a program back then, the program was the OS, everyone used asm back then. Using an archaic language like C++ now is sheer stupidity. Having to manually manage memory back when you were writing directly to hardware addresses and had full control of the CPU, but that kind of programming is gone with mondern OS's. You can call it astroturfing all you want, but languages like Go, D and Rust are going to take over and eliminate all the stupid time wasting errors that could be eliminated with garbage collection. Basically you should be able to look at code and know what it does, not poke around with a debugger and static anaylisis to try and find out what the program might do because the code is to unsafe to trust on its own. There are a lot of people who make their living coding C/C++ whos work will be made obsolete by modern compiled languages, languages that should have caught on 15 years ago.

Objective-C.

>>39
a language that has C as a strict subset with unsafe OO bolted on
gtfo