You know its true

you know its true.

Other urls found in this thread:

python.org/dev/peps/pep-0526/
doc.pypy.org/en/latest/faq.html#would-type-annotations-help-pypy-s-performance
twitter.com/NSFWRedditImage

...

Java/C++ = a person with an actual job
Ruby = how to code guys?
Assembly = very specialized for a certain system

you know you have downs

HolyC

so every language is a meme? what is the Sup Forums approved programming language?

JavaScript

Go, #F, Swift

Brainfuck and GML master race here.

HolyC

The language of God. HolyC

So, assembly, C and C++ are best? Agreed.

LISP

HolyC

Mods please, put this on the sticky. remove that faggot stallman

saved b/c truth

C++ IS THE BEST

PROVE ME WRONG

*tips fedora*

HolyC

hurrr, assembly is the least abstracted and closest to the actual hardware, therefore only wizards use it! we are so smart

Roll

i've always imagined php programmers as more misguided than downsy, as in not knowing you can run code other than php on webservers. That type of shit.

Now that I think about it you'd probably have to have downs to not know something like that though.

1. it's not c, therefore your assertion is wrong since c is objectively the best language
2. c++ used to be passable but they keep doing that meme where they cater to retards and make the language worse every couple years so it sucks now.

I like Stallman, but would not mind Terry on the sticky

Also worth noting that the trend is that Oracle caters to the retards that want java to be more like C++ so they add more unneeded shit and clutter up the language, and the language ends up being garbage.
And the c++ maintainers cater to the downies that want C++ to be more like java, and end up polluting the standard libraries and making the language shittier over time.

And that's the story of why ANSI C is the only language worth your time.

>meanwhile, python
>every once in a while, the python "community" comes up with decent proposals that could legitimately improve the language. Then the specs and the details on how to implement those proposals are fully worked out until it can basically be plugged right in
>and then some autistic manchild named guido says "no" because he doesn't agree with the programming mainstream
>the next day he approves a syntax which lets you create "make-believe" types for variables. You can now pretend your variables have a type by putting a comment saying the type of the variable next to it.
>and thus over the years python continues its original purpose of serving some manchild's obsession with doing things that don't make sense

D

Any examples of good rejected proposals?

>You can now pretend your variables have a type by putting a comment saying the type of the variable next to it.

>mfw that's a real thing
Not sure if it's intended to be funny or sad.

>>and then some autistic manchild named guido says "no" because he doesn't agree with the programming mainstream
Kek. Is this why every time I look up something about Python on stack exchange, there's a comment calling shit "unpythonic"?

Python variables have types you retard - it's not fucking Forth.

Also why do you attack bloating up the language like Java, C++ but are mad when Python doesn't?

>Assembly is best

As someone who actively *works* with intel x86 assembly, I can tell you that the pic is absolute garbage. The only useful purpose of any program is that it handles shit automatically for you, and a program that deals and applies to build multiple paradigms without having to write the individual instructions for each one is, by definition, abstract. In other words, abstraction is power. And assembly is by far the -least- abstract of all languages. In fact, there is absolutely no abstraction at all. It may be closest to the metal, but only newbies think any such thing is in any way cool or edgy. It's fucking frustrating, having to go so far as to spell out to the CPU how to do basic fucking things like fucking add two integers from the stack. The only thing assembly is good for is programming specialized instructions that are unique to it that no generic programming language such as C can do. And even then, C and C++ both have inline assembly, which renders pure Assembly pretty fucking obsolete.

>Python variables have types you retard
That's correct but PEP 526 and 484 made is possible to add arbitrary data to names, functions and parameters.
Now you can do shit like
def function(numbers: List[int], sentence: str) -> float
The idea is to help static code analysis.

well considering theres somewhere around (last time i checked) 6000 PEPs, i'm sure you could skim and find some.

I actually have to go pretend to work for about an hour and a half, if the thread is still up when I get back I'll post some

Yes, but you can assign a dictionary to an int if you want to. Obviously variables have types. The point is they're not enforced.

>Also why do you attack bloating up the language like Java, C++ but are mad when Python doesn't?
either be one way or the other, dont be the autistic middle child. The flipflopping and honestly retarded shit guido has pulled when regarding typing over the last few years are honestly pathethic.


Anyhow, I'll be back for more autism in about an hour and a half.

That's pretty neat. I like python but I think it lacks some of the security. Most of the "rules" of the language are pretty much guidelines and invalid stuff will compile, like
num=5
pring num.invalid_mem

which is a very useful thing and has nothing to do with the type system - it's simply an annotation

It's dynamically typed. That doesn't mean it has no types or types are never enforced.
>the flipflopping
What are you talking about?

>theres somewhere around (last time i checked) 6000 PEPs
While I'm sure that there might be an actually good suggestion that was rejected, most of rejected PEPs are either incomplete or just plain ridiculous.
I figured you might know about some specific ones.

>invalid stuff will compile
Type annotations are supposed to help that but I have mixed feelings. All the latest additions have been very messy in general.
Just look at the entire async library.

Variables have a type, names don't, you are arguing over semantics here.

He is much more chan too, being a autist shut in, like us

How is correcting someone who's talking complete nonsense about "make-believe types" and can now "pretend variables have types" arguing semantics?

this
HolyC

Because when he said variable he meant the name in the local dict object that can be bound to anything regardless of the type.

So I've used all of them at some point in my life except for Haskell. What does that say about me?
>inb4 that I'm a human bean

He's not on the spectrum
just a schizo who isn't taking his meds

Which has no bearing on what he criticized.
I can also do:
def foo(bar):
if type(bar) != int:
raise TypeError

instead of using type hints + static code analysis

How is that playing pretend?

I'm amazed at how language wars survived throughout the decades. You'd think the CS culture would mature over the years but it's the same shit over and over again.

I understand your point.
I understand his point.

You'll have to continue the discussion with once he comes back.

Sadly I can't use type annotations in my current project because I need pypy for performance and it only supports 3.3 currently.

Forth.

>go

Its that part of the meeting where I pretend to hear stuff for the first time and I was just gonna make sure the thread was still alive, but I need to clarify some things. Again, phoneposting, shitty format probably, but here goes

-Guidos stance on strong typing has altered every time the issue has been brought up.
-youre trying to argue semantics because I said variable instead of "name". You know what I meant.
-guidos idea of what strong typing should even look like has also changed over time, resulting in what you see now where you can declare type variables in function declarations etc. in a proper way, but you have to do that joke syntax with comments to declare types
-As a result, since they're, yknow, fucking comments, theyre discarded by the compiler and have no bearing on performance
-as a result, the only benefit of declaring types has been for third party tools like mypy (which somehow went from a student project to an actual fairly big deal due to how this entire thing has been handled by Guido) and post compile checks. Congratulations, you have added standard "syntax" for fucking linting.

Cant into quotes on phone, but that code you posted is just fucking ridiculous and you know it. If this was done at the compiler level, your code would becomr more efficient. Checking it manually like that just fucked your efficiency even more.
-have more to post but ill save that for when im back typing on a pc

>theyre discarded by the compiler
from typing import List
def f(a: int, b: "some shit", c: List[str]) -> List[float]:
return [1,2,3]

print(f.__annotations__) # {'c': typing.List[str], 'return': typing.List[float], 'b': 'some shit', 'a': }

They should've just agreed on a docstring standard that includes type information in such a way that is easy to parse by linters.
Jedi can apparently parse numpy and google docstring formats.

Missed this one
>but you have to do that joke syntax with comments to declare types
python.org/dev/peps/pep-0526/ fixed

>-youre trying to argue semantics because I said variable instead of "name". You know what I meant.
It doesn't make your original critic any more valid.
>guidos idea of what strong typing should even look like has also changed over time
What would be wrong that?
>As a result, since they're, yknow, fucking comments, theyre discarded by the compiler and have no bearing on performance
So what? No one said it was for performance.
Guido even lists that explicitly in "Non-goals" in the PEP.
>Congratulations, you have added standard "syntax" for fucking linting.
Which fits Python's philosophy of having consistent code format very well.
Again, I don't see the problem. Having static-code analysis like that is extremely useful and you don't have to be annoyed by ten code bases using ten different tools with ten different formats.
>Cant into quotes on phone, but that code you posted is just fucking ridiculous and you know it.
If I was obsessed with performance I wouldn't be using Python.
And type checks like that are useful for some cases. You can't always rely on duck typing.
Even some builtin Python functions do some type checks, e.g. "abc"+123

...

Before I start replying, you might not believe this, but I actually spend probably 75% of my programming time at work with Python (has been that way for a bit over a year) and believe it or not I actually do like Python. I think it's a good language, hence why I use it in a majority of my personal projects.

The fact that I like Python doesn't make me automatically ignore all the shit that's wrong with it. The language can be better, but sadly shitty PEPs and guido's personal vendetta against common sense are impeding progress.

Anyhow,
>It doesn't make your original critic any more valid.
Here, I'll even use the 3.6 half assed syntax for you:
my_var: int = "CIANIGGERS"
is valid at compile time. You might think that's OK, but what's the point of adding a type if the compiler is going to completely ignore it? You're still at the point where you need third party tools to improve your program's performance (i.e. mypy)

>What would be wrong that?
>So what? No one said it was for performance.
And that's where you're wrong. The entire push for types was for performance. Don't know if you know this, but it just so happens python is a decent language for science, and has a chance to be "the" science language. R is still pretty popular.

When you're fitting/predicting models using fucking terabytes or more of data, it makes a huge fucking difference if your data is typed. See some of the examples on mypy's website for the kinds of improvements you get for even simple scripts.
(post 1/2)

cont Essentially, this is the evolution of Guido's view on strong typing:
>python is this fucking revolutionary thing im making and so i'm never adding strong typing
>entities like Google start developing standards for documentation, and these include the "expected" type of variables. As is standard with every other documentation tool for every other fucking language.
>machine learning really takes off, but performance is a big issue
>the community finally tickles guido's balls enough that he approves the first half assed version of typing, which only helps when using third party tools
>muh backwards compatibility, i don't like the way this looks, this looks too much like X language type defs, etc.
>finally reach an agreement for "strong" typing (the new 3.6 syntax)
>it still does fucking nothing for the compiler, still have to use third party tools to benefit from performance improvements.


>Guido even lists that explicitly in "Non-goals" in the PEP.
That's because Guido a fucking manchild. Ask Google or Facebook what they think is the bigger deal, that they now have a standard syntax for fucking linting or that they can now make their learning frameworks insanely more efficient.

>If I was obsessed with performance I wouldn't be using Python.
Not an argument. Obviously you still do manual type checks for some things from time to time, but you were implying it was feasible or a good idea to type check every fucking variable manually. It's not. That's the compilers job. Or in Python's case, that's mypy's job.

...

why is javascript not accurately portrayed? She should be wearing at least 15 more layers of clothing and look more insecure about herself.

...

(I'm not the user you replied to)
>Ask Google or Facebook what they think is the bigger deal, that they now have a standard syntax for fucking linting or that they can now make their learning frameworks insanely more efficient
doc.pypy.org/en/latest/faq.html#would-type-annotations-help-pypy-s-performance

Clojure.

gentoo

>but what's the point of adding a type if the compiler is going to completely ignore it?
For static code analysis.
That should be very clear to anyone by now.

>And that's where you're wrong. The entire push for types was for performance
It has types! What I'm assuming you're talking about is static typing.
Type hints are not about a push for static typing - Guido even states in the PEP that Python will always be dynamically typed.
The same PEP where Guido also states that it has nothing to do performance.
So if you keep making claims like that, give me an actual source.

>When you're fitting/predicting models using fucking terabytes or more of data, it makes a huge fucking difference if your data is typed.
Yes, static typing improves performance. I've never claimed otherwise.

But you fail to understand that type hints are not about getting static typing into Python. The PEP could not be more clear about that.

>See some of the examples on mypy's website for the kinds of improvements you get for even simple scripts.
What the hell are you talking about? Mypy doesn't aim to do any performance improvements at all. It's stated right in their FAQ.

>python is this fucking revolutionary thing im making and so i'm never adding strong typing
Python was always strongly typed. What the hell are you talking about?

>Ask Google or Facebook what they think is the bigger deal
Helping to make your large code base more correct and maintainable is a pretty big deal too. Especially for web applications that tend to be bottlenecked by disk and network I/O not CPU time.

Ahmed is definitely JavaScript. Especially on the server side.

Lisp or it's variant: Scheme.

If you dont use one of these programming languages you dont know even what a programming language is capable of

I'm using machine code.

Sorry, I don't know enough about haskell to understand the picture

this or carmack

If you write assembly for anything other than microcontrollers you are deluding yourself into thinking you are close to the metal without considering ROBs, O3 and similar effects.

I'm not a little Indian boy.

C# is not for pajeeters.

Agreed.

...

>Assembly
Embedded developers (with autism).

>Java
Either curryniggers or old-shit-software maintainers that get rich while doing not all that fucking much.

>C#
Either curryniggers or Xamarin cunts (which might in fact also be curryniggers).

>Python
Wankers that don't want to deal with learning bash/shellscript.

>Haskell
Literally who's.

>C
Embedded developers (without autism).

>C++
Wannabe embedded developers.

>Ruby
Hipsters.

>PHP
Hipsters from another timezone.

>HTML/CSS/Javascript
See Ruby.

>Perl
>implying anyone is still using Perl

>Visual Basic
fucks born in the 80's and got into programming in the 90's.

>ActionScript
The newgrounds community.

>Go
Google drones, or basically also hipsters.

>Swift
See Go, but substitute with Apple drones.

>COBOL
Rich fucks (because they fucking know COBOL).

>Anything else
Egocentric fucks that know fuckall about anything.

Is there an English version?

I'm still using Perl for everything. Only problem I have with it is async and event based stuff, but no one else does it well either. It's a frustrating mess no matter the language

this

long overdue

Yeah, he deserves it.

>python2
>python3
/arguement

APL/FORTH = Wizard

What is the best way to start with ASM, good documentation, explanations, etc...

Does anybody actually write assembly for a living any more? I enjoy using it but it seems employment opportunities are limited

with how things are these days you are better off writing something and then try to sell it.

Punch cards.

I was waiting for this meme since the day I was born. Thank you OP, I understand the language classifications now.

THIS
Won't shut up before this happens

if tipple 7's terry davis gets stickied tomorrow

MR MODS,

TEAR DOWN THAT STICKY

>go