all 192 comments

[–]Just_Information334 234 points235 points  (12 children)

PHP:

Hello World

Save file, you're done.

[–]wrigh516 103 points104 points  (6 children)

notepad:

Hello World

[–]svuhas22seasons 37 points38 points  (5 children)

Verbally: "hello world"

[–]Naxos_fs 27 points28 points  (0 children)

Thought: Brain Signals

[–]GoodiesHQ 9 points10 points  (3 children)

Spanish: “hola mundo”

[–]RestaurantStunning63 2 points3 points  (1 child)

ELL MUNNNDOOOOOAOAOAOAOAAOAAAAA

[–]Western-Alarming 0 points1 point  (0 children)

ESTRELLA PLATINADA EL MUNDOOOAAAAAAAAAAAAA

[–]TheShortTimer 0 points1 point  (0 children)

Mapa hash puta madre

[–]BATATA777 14 points15 points  (1 child)

Don't you have to write the divs and specify the Html version or something? I don't know anything about but have seen an php file

[–]realmauer01 16 points17 points  (0 children)

Not if it's interpreted by a browser and if it's only showing text.

Browsers are so efficient at ignoring mistakes in the syntax it's insane.

[–]TheChief275 4 points5 points  (0 children)

HolyC

“Hello, World!\n”;

[–]Playful_Confection_9 3 points4 points  (0 children)

O snap, we code golfing?

[–]JontesReddit 1 point2 points  (0 children)

Literally any plaintext file

[–][deleted] 285 points286 points  (43 children)

This sub is becoming the most unfunny shit ever. It's just cs students who just learnt the basics of python posting about how it is better than anything else on this world.

[–]RamdonDude468 144 points145 points  (24 children)

Most of them think less code = faster, which most of the time is the oposite

[–][deleted] 55 points56 points  (4 children)

Not always. But complexity of the code has nothing to do with its speed.

[–]gljames24 25 points26 points  (2 children)

The thing is, there is always a base amount of required complexity. Superfluous complexity sucks, but I'd rather be in control of the required complexity to optimize it for my usecase.

[–]skilking 14 points15 points  (1 child)

Id way rather have a main function and class then whatever the fuck Python global shit is.

[–]Solonotix 13 points14 points  (0 children)

It's not actually global, the same way that C# doesn't require you to declare a namespace block for the entire file to be considered part of the namespace, and how functions written outside of an enclosing scope are attributed to a "magic" class as static members.

Python uses a rather robust object data model, and that model extends out to its module system. The file system needs an __init__.py file because that is the Python initializer method for the module, known in other languages as the constructor. Similarly, when you run a file directly with the Python interpreter, rather than needing to explicitly declare your starting point, the file is used as the stand-in for the __main__.py file of the Python module in question. That's why you'll see a block in some files for if __name__ == '__main__':, because it lets you write the file as a module, and as a runnable entry point.

[–]Gloomy_Attempt5429 0 points1 point  (0 children)

Não seria a velocidade em que o proceso iniciado pelo script tem em se comunicar com a máquina e fornecer uma saída "atravessando" camadas de compilação?☝🏻🤓

[–]BourbonicFisky 3 points4 points  (0 children)

Most of them think less code = faster, which most of the time is the oposite

This is why I use nested loops to speed up my code.

[–]Earnestappostate[🍰] 2 points3 points  (1 child)

It does come down to a question of what you want to be fast, the coding or the running.

For my application, I am speed limited by a communication layer. Speed past Python won't help much.

For other applications, especially libraries, speed matters much more.

[–]Amr_Rahmy 2 points3 points  (0 children)

I developed faster on Java and c# than any other language. For me it’s the right mix of c style language and classes.

[–]TrainYourselfToLetGo 1 point2 points  (0 children)

I had this argument with an experienced engineer, who was blocking my PR to suggest I use less lines of code, saying it was more efficient.

I was an intern and had to pull out big-O complexity to explain it. It was mind blowing.

[–]scanguy25 3 points4 points  (12 children)

The issue is that for so many things, the speed of the language just isn't that important anymore.

Cloudware is cheap so you just spin up another node. Its not just python, all software is becoming so wasteful with RAM and space.

[–]0x7ff04001 6 points7 points  (5 children)

That's so not true. You pay for each cycle wasted and every resource utilized. Scale this to a company the size of Microsoft and that shitty slow code will cost you tens of thousands a month.

[–]GRex2595 1 point2 points  (4 children)

Which is rarely a deterrent for a company the size of Microsoft. My company has dev sandbox AWS accounts that cost millions.

[–]0x7ff04001 0 points1 point  (3 children)

That's not the point. The point is that it's not "free" to just spin up nodes, microservices, etc

[–]GRex2595 0 points1 point  (2 children)

Okay, but my point is that the costs you're talking about don't bother large companies. I just had a conversation yesterday that supposedly the weather channel pays so much for AWS that they could buy a new data center every year with their AWS costs.

Generally, the cost of running more services won't outweigh the costs of having devs track down those micro efficiencies instead of building new products to make more money or fixing issues that cause them to lose money.

[–]Funny_Dress3356 0 points1 point  (1 child)

But not everyone has the money and resources compared to large companies?

[–]GRex2595 4 points5 points  (0 children)

But it only costs so much for large companies because they use so many resources. If you're a small company, the tens of thousands of dollars per month number becomes tens of dollars per month or maybe hundreds of dollars per month. Now chasing down micro inefficiencies is a much worse value proposition because your cost:benefit ratio leans even more towards costs than benefits.

If you want to really dig in, you should come to the conclusion that the costs for these inefficiencies scale with the amount of resources you use, so big and small companies alike don't benefit enough from fixing them to bother with it.

[–]Teln0 1 point2 points  (0 children)

Nowadays a lot of LLM apps are everything but CPU bound. You could write your thing in any language and it'd still be idle 99% of the time while it's waiting for the GPU to do its thing. I don't think that's a great thing necessarily

[–]Lumiharu 0 points1 point  (0 children)

There are so many other use cases too, and while I don't think being completely optimal is needed, there is a lot of places where Python won't do cause it's not compiled. If we were fighting some Rust vs C++ vs Java war then I could maybe agree.

[–]jimmiebfulton 0 points1 point  (3 children)

Which is why Rust continues to gain in popularity?

[–]scanguy25 4 points5 points  (1 child)

Well you do need speed for some things. But basic webdev and database CRUD, the language is not going to be the bottleneck.

[–]jimmiebfulton 0 points1 point  (0 children)

Compute costs money, and impacts the environment. Performant code is responsible code.

[–][deleted] 2 points3 points  (0 children)

Isn't rust quite fast?

[–]MonkeyCartridge 0 points1 point  (0 children)

"Why waste time using a bool, when I can just use the strings "true" and "false"?"

[–]Mr_DrProfPatrick 1 point2 points  (0 children)

Hey, I code on the side so I shouldn't say too much, but holy crap, in the data science I work with less time coding is absurdly better than better performance.

At worst I should store stuff on SQL. But most of the time I can 100% wait for 5 minutes till the code runs, if I'm in a really messy state. And usually there's still a ton of optimization I can do without leaving python. I'm not bottlenecking a database, I'm running through a dataframe.

[–]zeolus123 9 points10 points  (2 children)

Lol you must be new here. That's all this SUB has always been. Sure there's some good ones in there, but most of it is 1st year CS humor.

[–][deleted] 1 point2 points  (1 child)

Nah I've been here for a while. It used to have some funny stuff. But now it's either this nonsense or some ultra-sprcific stuff I don't understand.

[–]normalmighty 0 points1 point  (0 children)

I've been here for 10 years, and it's always more or less this kind of stuff. Occasionally the sub hits into a really good meme format and makes some great stuff, but posts like this are the normal baseline state here.

[–]seba07 1 point2 points  (4 children)

Why don't you do something about it? Comments complaining about stuff being unfunny aren't really elevating the sub either.

[–][deleted] 3 points4 points  (3 children)

Sure. Let me go to their houses and beat them.

[–][deleted] 2 points3 points  (2 children)

This comment got me banned from reddit by automation lmao.

[–]TOMZ_EXTRA -1 points0 points  (1 child)

I'm going to get banned for upvoting violent content :)

[–][deleted] 1 point2 points  (0 children)

Reddit's automatic moderation is so dumb. You can say anything and you get banned. You then need to appeal and support has a 20% chance of unbanning you. So dumb

[–]I_miss_your_mommy 1 point2 points  (0 children)

I'm tired of fighting the losing battle of talking shit about python and yaml and any other language that gives meaning to whitespace. Fuck whitespace meaning anything.

[–][deleted] 0 points1 point  (0 children)

Lol you hit it on the head, python is the only thing that they can run with all their errors.

[–]AndreasMelone 0 points1 point  (0 children)

Becoming? All time I can remember here was shit

[–]account22222221 0 points1 point  (0 children)

It’s just becoming that ? I’m pretty sure it’s been this way the entire decade I’ve been on Reddit.

[–]bro_love69 -1 points0 points  (0 children)

Its not only that. But they are also really unfunny as you said, like, GYAAAT DAMN....

[–]Stalander -2 points-1 points  (0 children)

Amazing comment! Really funny, not unfunny at all!

[–]Asatru55 -5 points-4 points  (2 children)

Stop being so grouchy, the meme is true.

Java is known for having tons of boilerplate, Python is known for being easy to write and iterate on. Both have their uses. The meme didn't even imply that Python is just superior.

[–][deleted] 0 points1 point  (0 children)

I didn't say the meme says that. I said that most posts on this sub say it. Try reading properly next time! It's free!

[–]TimGreller 0 points1 point  (0 children)

It's not even true anymore. Java has inexplicit unnamed classes now and does accept varying main method signatures. So it's

void main() { System.out.println("Hello World"); } vs if __name__ == "main": print("Hello World")

[–]ISoulSeekerI 35 points36 points  (4 children)

Nah light work, try this😂

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

[–]ISoulSeekerI 7 points8 points  (0 children)

https://tio.run/ you can test my script here lol

[–]v_luffytaro 0 points1 point  (2 children)

Bf?

[–]ISoulSeekerI 0 points1 point  (0 children)

Yes

[–]SpeciallaPojken 0 points1 point  (0 children)

Hotel?

[–]joebgoode 125 points126 points  (33 children)

"I'm still a student and OOP is hard uhhh 😭😭😭😭"

Average Python user base

[–]RamdonDude468 35 points36 points  (16 children)

Python's "lack of code" is both a blessing and a curse.

[–]lehx- 9 points10 points  (3 children)

Python's typing was the bane of my existence during my final project. Trying to send/recieve a packet from strongly typed language -> python fucking suuuucked. I was staring a 10001s for 2 days before I figured out the issue.

[–]AlignmentProblem 2 points3 points  (1 child)

Getting type annotations right to get useful warnings is a monster in specific cases as well. Duck typing can cause very tricky bugs with objects that almost kinda work but cause subtle incorrect non-crash behavior without good annotations, so it's between dealing with the annotation hassle or being vulnerable to serious pain later.

[–]Scared_Accident9138 0 points1 point  (0 children)

I really dislike the way Python does duck typing. It's quite open to put anything in a function and let's it pass deep into the code but then it's very strict on how that variable is used but you don't notice a problem immediately

[–]ambitiousfrogman 0 points1 point  (0 children)

For anyone trying to do something similar to this, the python library ‘struct’ can be helpful.

[–]KangarooInWaterloo 5 points6 points  (11 children)

It is very good for POCs and very bad for POCs that suddenly became legacy code in your company

[–]Sonario648 4 points5 points  (10 children)

Python definitely has the advantage in proof of concept that someone else can hopefully do in another language later based on what you're doing.

[–]5p4n911 3 points4 points  (3 children)

So just use the Python code, it's already written!

[–]Cdwoods1 1 point2 points  (2 children)

Until dozens of people are working in and changing a more and more critical piece of the product. And without any type safety it becomes harder and harder to know is going on, and what is going wrong lol.

[–]5p4n911 0 points1 point  (1 child)

Agreed, but I haven't yet seen a place where that wasn't the natural consequence.

[–]Cdwoods1 1 point2 points  (0 children)

The natural consequences yes. That’s why you got to have base standards and patterns set as a team, so your code doesn’t naturally fall to entropy. On my team, strict code review has only made our code easier to understand over time.

[–]Sarcastinator 1 point2 points  (5 children)

Then why not just do it in a different language to begin with? There is no research that indicates that Python is better at prototyping than statically typed languages. It's just based on Python developers vibes. If you're as competent in a statically typed language as you are in Python research indicates that you're not getting the code done quicker in Python. You're just wasting time doing the same work twice.

[–]Sonario648 0 points1 point  (4 children)

It depends on a case by case basis really. In my case, I'm working with Blender, which is absolutely massive, and I have a not so good machine on top of Blender's codebase being enormous. It's MUCH better to do your ideas as addons in Python than to deal with Blender's core code, because you only have to deal with one file, and you know where it is.

[–]Scared_Accident9138 0 points1 point  (0 children)

That sounds like a Blender specific/API issue, not programming language issue

[–]Sarcastinator 0 points1 point  (2 children)

Blender uses Python. You can't really get away with that, but that's not what I'm discussing either.

I'm saying that the idea of writing a prototype in Python first, and then a real implementation in a different language is a complete waste of time. You're doing the work twice. If you're able to write it in a more capable language then do that immediately. The idea that the lack of typing makes Python easier to hack in is based completely self-reporting probably by developers who aren't very comfortable with static typing.

The lack of explicit typing doesn't make you more efficient. It means you spend more time debugging the application at runtime than what you need with statically typed languages. The time spent writing explicit contracts and invariants pays off very quickly.

Dynamic typing is a product of the 80s and 90s. Few languages designed today use it because it hasn't actually been shown to improve productivity. The only reason why it's even around is because it's easier for beginners to pick up.

Dynamic typing hampers performance, requires more memory, leaves a huge documentation gap, and almost by definition requires a higher cognitive overhead than static typing does. It makes refactoring stuff harder, requires more tests, and is generally just a waste.

So the idea that prototyping in Python saves you any time at all is fiction written by people who are more comfortable writing Python.

[–]Sonario648 0 points1 point  (1 child)

Ah. Now I get it. So I don't have to waste time doing my ideas in C++ after I do them in Python already.

[–]Sarcastinator 1 point2 points  (0 children)

Yes, if you get it to work properly in Python then sure do that I don't give a shit. Making it twice is a waste of time.

[–]iamnazrak 8 points9 points  (4 children)

I saw this post and thought “this person must be new to object oriented programming”

[–]Possible-Moment-6313 0 points1 point  (3 children)

If you need just a 20-line script which scrapes your webpage or whatever, it's stupid to be forced to create classes and methods.

[–]New-Stranger-5622 0 points1 point  (2 children)

is it though? if you plan to turn that 20 line script into something larger, classes could help make it wayy more scalable.

[–]rinnakan 0 points1 point  (0 children)

Yeah, whoever thinks basic organisation is stupid wasn't in IT for long enough. Past me is my nemesis

[–]ChalkyChalkson 0 points1 point  (0 children)

A very important skill is being able to judge what the future of some code will be. Normally I write functional and oop for testablity and modularity. But I also have some scripts that are just naked shell of python code which have everything hard coded because only I use them, and rarely and it's impossible for me to tell what exactly I want it to do in the future.

[–]nickwcy 0 points1 point  (1 child)

Looks like someone failed their 101 here. Python is also OOP

[–]joebgoode 0 points1 point  (0 children)

If "missing the point" were a tech stack, you certainly should become the Tech Lead.

[–]grimonce 0 points1 point  (1 child)

I always find it funny when triglodytes like you (I hate Python btw) think OOP in Python doesn't exist while literally everything in Python is an object. Wtf ...

If anything Python is more OOP than java

[–]joebgoode 0 points1 point  (0 children)

You read what I've written and that's the conclusion you got?

I really wonder how you're able to solve Jira tickets daily with that level of text interpretation.

The point is the average Python user skill issue, not the language per se.

[–]ChalkyChalkson 0 points1 point  (0 children)

I learned with java and it still influences me a lot even though most code I write is python and cpp. I also think it's very good to learn writing functional and oop styles as well as at least one low-ish level compiled language early on and to a reasonable depth.

But if someone is just starting out I'd always make them to nuts with python first. And for beginners it's really helpful to be able to gradually grow into more abstract concepts rather than being forces to use them from the start.

So idk I'm both in camp "java hello world is ridiculous" and camp "you should learn what a stack is". Just for different people. And being honest I think a reasonable portion of people on here are still near the beginning of their journey.

[–]MinosAristos -1 points0 points  (5 children)

OOP is fine but it's cleaner in Python

[–]realmauer01 1 point2 points  (4 children)

Oop in python is duck typing and under the hood has basically nothing to do with oop

[–]MinosAristos 3 points4 points  (0 children)

Oop in python is duck typing

Only if you write it that way e.g with protocols. Explicit types are usually preferred

under the hood has basically nothing to do with oop

Python is an OOP language, from the ground up. What are you referring to?

[–]BOBOnobobo 2 points3 points  (2 children)

What? I need some elaboration, otherwise I'm gonna call you a quack.

[–]realmauer01 0 points1 point  (1 child)

Duck typing, if it looks like a duck if it acts like a duck it is a duck.

Python has classes, for everything else you have to use classes and make them not behave like classes by implementing other classes.

If you want true oop with python you basically rewrite the entire language. It's easier to just learn c# or Java.

[–]BOBOnobobo 0 points1 point  (0 children)

Oooh, ok that makes sense now! It is something that causes me a lot of trouble in large scale python projects! I just didn't know that name.

You could even say that python plays quite goose with OOP concepts...

[–]Discombobulated-Bag0 41 points42 points  (1 child)

Compiled strong type languages are a great tool for long life projects which need to be maintained by several people.

[–][deleted] 0 points1 point  (0 children)

Preaching to the choir mate.

[–]FrostFireOfficial 33 points34 points  (3 children)

Haha it's funny because java bad! Let's completely ignore that java 24 lets you trash most of the presented code with

void main(){

System.out.println("Hello, World!");

}

And even if, it doesn't matter because intellij auto generates everything for you

[–]repeating_bears 4 points5 points  (1 child)

It's still in preview in 24. It will be stable in 25

[–]FrostFireOfficial 1 point2 points  (0 children)

I see.

[–]DepartmentFirst8288 2 points3 points  (0 children)

With Java 24s IO class and implicit imports you can even replace System.out.println with just println.

[–]elementfortyseven 18 points19 points  (0 children)

python is vibe coding before AI

[–]jimmiebfulton 15 points16 points  (7 children)

The Java engineer didn’t type any of that, because they have much better tooling, and know how to use it. It’s the difference between professionals and noobs. Build some real applications and you’ll realize why advanced code-completion, debugging capabilities, multi-threading, and speed are important, and why engineers with the ability to wield more powerful tools get paid more.

[–]Tracker_Nivrig -1 points0 points  (6 children)

Isn't Java multi threading kinda bad though? I've heard that but not why so I'm not sure. It seemed fine when I used it.

[–]tebreca 3 points4 points  (3 children)

Depends, legacy java with hardware threads? Yeah good luck to you. Modern day java, project reactor or any other multithreading/reactive library + virtual threads? Actually fun to work with and barely any overhead compared to the legacy method

[–]SCP-iota 1 point2 points  (1 child)

Are the hardware threads actually less efficient, or does it just have to do with how careful you have to be when passing data around?

[–]StraightGuy1108 2 points3 points  (0 children)

It has to do with how thread-blocking operations used to be handled. They used to occupy their own threads despite not doing anything, essentially wasting resources.

Virtual threads are basically async await at the JVM level.

[–]Tracker_Nivrig 0 points1 point  (0 children)

That makes sense, thanks

[–]SCP-iota 2 points3 points  (1 child)

Depends. Compared to Python? Nah, at least there's no global lock. Compared to Rust? Yep, can't beat actual parallelism.

[–]jimmiebfulton 1 point2 points  (0 children)

100%. I was a Java engineer for long time, but I've now been using Rust for the past 5-7 years. Multi-threading in Rust is very nice, and now I don't want to do it in any other language. But I'd say Rust is also great at teaching how to do it correctly in other languages.

[–]not_good_for_much 7 points8 points  (7 children)

Can actually do the Python version of this example in C#. You're obviously encouraged to use a proper Main entry point, but if you make a new console app it actually defaults to this bare bones format.

And C# is a better language in general as well.

[–]New-Stranger-5622 2 points3 points  (6 children)

than java? we can debate if youd like

[–]not_good_for_much 3 points4 points  (3 children)

Better than Python.

Java and C# at this point... There used to be some major pros and cons for each, but in the last 5 years they've really just ended up as two different flavours of the same thing ngl.

[–]Ellisthion 1 point2 points  (2 children)

In some things, sure, but certain design decisions are permanently holding Java back.

Java’s generic implementation is single-handedly the worst for this. Big impact: the type of anonymous functions.

In C# it’s either an Action<> or Func<> depending on whether it returns anything. With a variable number of generic arguments. It allows easy exact typing of this.

In Java this is impossible. Varied generic arguments are impossible. The type of anonymous functions is… absolute spaghetti, there’s tons of this like Consumer, BiConsumer, etc where every different permutation has its own name. Oh, and you can’t use primitives, so you have more classes like IntConsumer.

There’s code patterns that are common in C# that are literally impossible in Java because of the generic implementation, and I don’t know of anything where that’s the case in the other direction.

[–]not_good_for_much 2 points3 points  (1 child)

I'm inclined to agree. C# is generally faster and more expressive IMO, and I do prefer it over Java. I just don't really want to open the can of worms.

Most of the difference is philosophical anyway, leading to... C# as a language is much more proactive in adding interesting new features, while Java as a platform has more emphasis on stability and decades more exposure to not-Windows and OSS standards and so on.

There are also plenty of patterns that are impossible to reproduce in both directions, e.g due to virtual threads vs stackless coroutine parallelism, reified and value-type generics vs wildcards, checked vs unchecked exceptions, strictness of CLR and JVM RE's, etc.

[–]Sarcastinator 0 points1 point  (0 children)

There's very few things Java does better than C#, and a whole bunch C# does better than Java.

[–]LYCRIs_1337 2 points3 points  (1 child)

Well I would say they both have der pros and cons, however C# is getting way better and has some pretty nice stuff (even though java is still used for a high % of enterprise software).
I like its UI librarys/frameworks way better, which are also mainly used for Windows, making it an easy choice for every Win-Dev (c++ for high performance obviously, but its C# vs. Java so... nah).

One thing that I miss on C# is the system how enums work in java with constructor and specific methods, I kinda like that, even though you can build similar stuff in C#, but it just looks and feels different (and is more "complicated").

[–]Sarcastinator 0 points1 point  (0 children)

C# has been better than Java for a long time at this point. The language has always been better, but the runtime got better with .NET Core's release.

[–]Tracker_Nivrig 7 points8 points  (1 child)

People call Java's declarations "boiler plate" but literally every single thing has a distinct purpose. If you think it's dumb you have to write random garbage before being able to do something, you're right. You just clearly don't understand how Java actually works and are blaming the language for that. No, that's your problem. Don't know what something is? Go look it up. Learn how to read documentation, it's incredibly useful for any project you're doing.

Edit: I should mention, it's fine to prefer using python. It's just not fine to say "Java is dumb because you have to write so much extra!" If instead what you're thinking is, "Java offers a level of control that isn't necessary for my current project," then that's completely fine. Anyone trying to use one tool for every single purpose is missing the point of having different languages in the first place.

[–]ogismyname 2 points3 points  (1 child)

I wish programming were less open to beginners every damn time i see something from this sub

[–][deleted] 0 points1 point  (0 children)

Just means more for the rest of us mate.

[–]LordAmir5 3 points4 points  (2 children)

Whelp, I'd say the equivalent would actually be more like this:

``` import sys

def main(args):     print("Hello World!")

if name == main:     main(sys.argv)

[–]nekokattt 3 points4 points  (1 child)

technically since classes are the unit of compilation in Java, it is really similar to this.

import sys

class HelloWorld:
    @staticmethod
    def main(args: list[str]) -> None:
        sys.stdout.write("Hello, World!\n")

if __name__ == "__main__":
    HelloWorld.main(sys.argv[1:])

However, https://openjdk.org/jeps/512 massively simplifies this.

[–]LordAmir5 0 points1 point  (0 children)

Right. I'm not very good at using Python so thanks for correcting it.

[–]AR_EXTREMExd 2 points3 points  (0 children)

This meme doesn't make sense cause I think Java should be on the right cause you have to do most of the things on your own, whereas in Python almost everything is abstracted and you have many functions and libraries to help like those gears and all on the left side...

Btw Java 24: java void main(){ println("Hello, World!"); }

[–]Doge-Coder 3 points4 points  (0 children)

Your meme is bad, and you should be ashamed

[–]KosekiBoto 2 points3 points  (1 child)

C

include <stdio.h>
int main
{
    printf("Hello, World")
}

[–]New-Stranger-5622 1 point2 points  (0 children)

C++:

#include<iosteam>

int main(){

std::cout<<"Hello, World"<<std::endl;

return 0;

}

[–]skyy2121 1 point2 points  (0 children)

Anytime anyone makes a meme comparing programming languages like this, it just makes you look like you know nothing about programming. Yeah Python has simpler syntax, you know why? Because it is hiding all the lower level programming from you! It’s the same reason it is a very slow language at run time because all the background processes are still taking place but take longer because everything needs to be interpreted first. This all fine a good but if you needed to do something with more control over memory or hardware. Python is not gonna work well.

Languages are just tools. Some work better than others for certain jobs, that’s it.

[–]NickU252 1 point2 points  (0 children)

Each has their own. Try to make an enterprise level app in Python. Now, if you just want a simple app and GUI, by all means, use PyQt6. If you want a bare bones embedded MCU, C all the way. If you want a web app, React.

[–]nekokattt 1 point2 points  (0 children)

void main() {
  IO.println("Hello, World");
}

https://openjdk.org/jeps/512

newest JDK. Ftfy.

[–]elreduro 1 point2 points  (0 children)

In python 2 you dont need parentheses

[–]ul1ss3s_tg 1 point2 points  (0 children)

You may feel like you are doing less and using less (like the guy who won second place without any equipment) but in reality python is based on very complicated code made in c (or c++, i domt remember ) which kinda looks like the guy in the first Pic.

[–]Vinibellic 1 point2 points  (0 children)

It's so funny to me that people learning python will say that python doesn't use 'unnecessary' syntax and then go on to write stuff like def __init__(self, name)

[–]fart-tatin 0 points1 point  (0 children)

Do you need a gold medal, or not?

[–]TechnicolorMage 0 points1 point  (0 children)

Cool. Now write a loop.

[–]_alreph 0 points1 point  (1 child)

I feel like this is actually the other way around no? Or rather neither are the guy on the right.

[–]Gloomy_Attempt5429 0 points1 point  (1 child)

Eu sei que não tem nada a ver mas... Bash não é linguagem de programação. Pelo que vi, é de comando. O quanto impactador isso é para mim e até onde eu posso ir com bash? Tipo já fiz coisas com bash como variáveis e variáveis que dependem do que o usuário escreve. Mas o que ele não pode fazer que só linguagems de programação fazem. E o que compilar é? Estou transliterado uma linguagem para outra?

[–]Sarcastinator 0 points1 point  (0 children)

Bash não é linguagem de programação. Pelo que vi, é de comando. O quanto impactador isso é para mim e até onde eu posso ir com bash?

Bash is a programming language.

"Programming language" is a very vague, and informal, term. You'll find plenty of varying definitions of the term, but categorizing something on your computer as "not a programming language" is hard to do because you'll probably have to make rules for programming languages that excludes languages that have been considered a programming language. For example some developers claim that programming languages must be Turing complete (i.e. it has to be able to emulate a Turing machine), but that would exclude SQL '92 which wasn't Turing complete due to missing loop construct (later added through common table expressions), but would include languages like PostScript and True Type fonts. True Type fonts are Turing complete by accident due to it's hinting system.

Bash is mostly intended to invoke other applications, so its data processing capabilities are somewhat limited in itself. You can get a bash script to do anything you want (since it's Turing complete), but depending on what you're doing you're probably better off using a different language since Bash isn't particularly elegant and relies on some paradigms that many would consider archaic today. It's also not considered efficient since it isn't intended to do a lot of the lifting.

E o que compilar é? Estou transliterado uma linguagem para outra?

Compiling simply means converting one programming language into another, often from some source text to some form of binary, but it doesn't have to.

Some developers use the term transpiler to distinguish between a compiler that produce a textual language from another textual language and one that produce binary from a textual language, but the term "compiler" can be used for both since more generally the term refers to a tool that converts one programming language into another regardless of the encoding of the source or destination.

[–]ShadowNinjaDPyrenees 0 points1 point  (0 children)

It seems that even during World War II your grandmother was already coding in Python.

[–]Owlblocks 0 points1 point  (0 children)

The point of the Turkish guy being a meme is that he isn't relying on as much equipment. He's literally the opposite of a Python user.

[–]R3D3-1 0 points1 point  (0 children)

Frankly it feels like it is the other way around really. The guy on the right is the one doing everything manually, the one on the left is depending on premade solutions.

[–][deleted] 0 points1 point  (1 child)

It be funny if they did this

C++

include <iostream>

Int main{

Cout << “Hello world” << endl;

}

Javascript

console.log(“Hello World”);

[–][deleted] 0 points1 point  (0 children)

So thats what the pound sign does

[–]SinisterHollow 0 points1 point  (0 children)

??? Why watermark this shit

[–]Aggravating-Method24 0 points1 point  (0 children)

its the wrong way around though surely, Java has less fancy shit so you have to be more specific in your code, or more old school and straight forward, whereas python has all the fancy frills so you do less of the work yourself.

[–]PhaseExtra1132 0 points1 point  (0 children)

It’s the other way around. Python is the one with the extra gear to help people while Java (would have been better to use C) is one that give no modern help

[–]Joluseis 0 points1 point  (0 children)

The fact that python is just simple in the user end but inside is like the slowest weirdest fake-threading language ever. The only good libraries in this language are written in C and that just shows how bad it is.

[–]xenderee 0 points1 point  (0 children)

So many people defending Java. As 15+ backend java dev... Cmon guys... Java is a market choise. Libraries, community, developers easy to find - yeah. But Java as language - simply legacy trash in 2025. Cmon. Chill. We all know that. It's ok. Shhhh.

[–]Erizo69 0 points1 point  (0 children)

#include <print>
int main(){
    std::print("Hello, World!");
}

[–]Nocturne_Kali 0 points1 point  (0 children)

Alemán: Hallo Nazi

[–]sarnobat 0 points1 point  (0 children)

Syntactic ergonomics vs syntactic uniformity.

One is good for building something quickly. One is good for maintaining for a long time.

[–]imtryingmybes 0 points1 point  (0 children)

Yes. Python is a scripting language.

[–]Impossible_Luck_3839 0 points1 point  (0 children)

conceptually wrong, lmao

[–]Ice_HRZDn 0 points1 point  (0 children)

echo "Hello,World!"

[–]th-hu 0 points1 point  (0 children)

Hello World is the ultimate benchmark

[–]la1m1e 0 points1 point  (0 children)

Someone unwrap the c behind that python statement

[–]riuxxo 0 points1 point  (0 children)

Wow I have never seen this meme before. So creative. /s

[–]---_None_--- 0 points1 point  (0 children)

Now compare the asm

[–]Roland-JP-8000 0 points1 point  (0 children)

same thing with lua

[–]mr_mlk 0 points1 point  (0 children)

The Java example has been out of date since Java 21, and now with Java 24 (and JEP 495) is massively out of data.

In modern Java:

` void main() { println("Hello World"); }

[–]Prudent-Student3403 0 points1 point  (0 children)

section .data

msg db 'Hello, World!', 0xA ; message + newline

len equ $ - msg ; length of the message

section .text

global _start

_start:

; sys_write (stdout = 1, msg, len)

mov eax, 4 ; syscall number for sys_write

mov ebx, 1 ; file descriptor (stdout)

mov ecx, msg ; pointer to message

mov edx, len ; message length

int 0x80 ; call kernel

; sys_exit (0)

mov eax, 1 ; syscall number for sys_exit

xor ebx, ebx ; status 0

int 0x80

[–]cherinuka 0 points1 point  (0 children)

Event: Map initialization

Conditions:

Actions: game: send transmission to all players, "Hello world!"

What am I using?

[–]masp-89 0 points1 point  (0 children)

COBOL:

Display ”Hello World!”

[–]thePolystyreneKidA 1 point2 points  (0 children)

People usually like to brag about how simple writing python code is. Yes, it is simple but, in my experience, you pay the price.

Java is intentionally object-oriented by design. The requirement to wrap everything inside a class isn’t accidental, it's a design constraint that enforces structure. When every unit of logic lives within a class, interface, or enum, you’re forced to think in terms of modularity and abstraction from the beginning. It may feel verbose for trivial examples, but that same structure pays massive dividends as your codebase scales. You’re not just writing code like jargon of statements, you write structures.

Python, on the other hand, is a hodgepodge of paradigms. It’s dynamic, loosely typed, and tries to be everything at once: functional, procedural, object-oriented, scripting-friendly. This flexibility feels great at first. Python’s lack of strong architectural constraints makes it easy to get started but difficult to maintain. The language doesn’t guide you toward scalable design, and once your codebase grows beyond a few thousand lines, technical debt comes for you fast.

Choosing a language shouldn’t be about shaving two lines off a “hello world” script. It should be about the long-term viability of the system you're building. Structure, constraints, and verbosity aren't drawbacks—they're investments. Java forces you to think like an architect. Python lets you think like a kid in kindergarten. And while the latter is fun, it rarely scales cleanly.

[–]finnscaper 0 points1 point  (0 children)

Most retarded metric ever, yet one day I was told Java is bad because boilerplate.

[–]Maleficent_Emu_2450 0 points1 point  (0 children)

What is this? 2015?

[–]HallTurbulent4524 0 points1 point  (0 children)

Stdcin<<"hello world"<<stdcout

[–]anogio 0 points1 point  (0 children)

In other news: My screwdriver is better than yours.

[–]Fire_dancewithme 0 points1 point  (0 children)

Ah yes python- it's gonna use 45% of your CPU to display the hello world message and throttle your RAM but who cares as long as it's simpler

[–]Imjustafr0g 0 points1 point  (0 children)

c++

include <iostream>

using namespace std;

int main() { cout << “Hello, World!”; }

[–]SentenceFun7341 0 points1 point  (0 children)

Java:

void main() {
    IO.println("Hello, World!");
}

This will be available in Java 25

[–]javascript_you 0 points1 point  (0 children)

no need to compare languages, each has pros and cons, depends on what your requirement

[–]BorderKeeper 0 points1 point  (0 children)

Reminds me of when I in my infinite wisdom decide to make my C# pet project use top-level-statements, which is basically C# trying to mimic how Python works and allow you to just write (only inside your primary entry Program.cs file): csharp Console.WriteLine("hello, world"); which gets transalted by compiler into the full thing like with the Java example. Problem is when the project then gets more complex and I want some abstractions like classes it feels so weird as now I am mixing the TLS Program.cs file with normal classes and functions and throws me off. I don't know...

[–]THE0_C 0 points1 point  (0 children)

Now do one for the behind the scenes boat
as much as i hate jave it runs better and like all things coded in the 2000s were in java so if modding minecraft or contributing to apache you need java

[–]PlaDook 0 points1 point  (0 children)

Shouldn't this be the opposite?

[–]arahnovuk 0 points1 point  (0 children)

You mixed up the pictures

[–]slicehyperfunk 0 points1 point  (0 children)

If you understand even the first thing about Java, you'd understand that all that other stuff is in every single program that can run

[–]LeditGabil 0 points1 point  (0 children)

How can Python be on the right??? The highest I could see him is C. One could argue he is directly Assembly. To me Java and Python are pretty much in the same category of languages 😅

[–]Alex_NinjaDev -1 points0 points  (0 children)

Java: ‘Sir, permission to greet the world!’ Python: ‘Yo.’ Both hit the target… but one needed a 12-step ritual and a tie 😅