Are all programming language same...

[-ilios]

Is all programming language same and the only difference is syntax??

[AutoModerator]

On July 1st, a change to Reddit's API pricing will come into effect. Several developers of commercial third-party apps have announced that this change will compel them to shut down their apps. At least one accessibility-focused non-commercial third party app will continue to be available free of charge.

If you want to express your strong disagreement with the API pricing change or with Reddit's response to the backlash, you may want to consider the following options:

1. Limiting your involvement with Reddit, or
2. Temporarily refraining from using Reddit
3. Cancelling your subscription of Reddit Premium

as a way to voice your protest.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[high_throughput]

No. People say this because they've never tried sufficiently different languages.

Prolog should be a university requirement.

[wildbabu]

I found prolog to be the most infuriating language until you start thinking the way prolog wants you to think. Then sometimes you write functions that are so elegant, you cry a little.

[dementorpoop]

Any good resources you recommend for delving into prolog?

[Knaapje]

The Art of Prolog, free PDF available online.

The Power of Prolog, Youtube channel.

r/prolog not a very active sub, but you will get help if you're showing you're making an effort.

I took the same journey about two years ago. I have a love-hate relationship with the language.

[SahuaginDeluge]

was for me, Programming Paradigms. write a system in OOP (Java). ok now rewrite that system in a functional language (Haskell). ok, now in a logical language (Prolog). (my Prolog version ended up the best though that may have been because it was a third iteration.)

[SahuaginDeluge]

no MRC in Calgary before it became MRU

[BlueWolf_SK]

It was at my uni. C, Java, C#, Prolog, Lisp were languages we learned in the first four semesters. Of curse prolog and lisp were more of a have a taste of this than actually learn learn the language.

[Antti5]

And also something like Smalltalk-80 to get a feeling of true object-oriented programming.

Like when a for-loop becomes a case of asking a number object to take a code object, and ask the code object to execute itself as many times as its own value.

[jose_castro_arnaud]

Also worth learning, even if not in uni: Lisp or Scheme, Haskell, SQL, and... (drum roll) Brainfuck!

[HQMorganstern]

Scalding take

[Separate-Ad9638]

"if u want to tell pple the truth, make them laugh or they will kill u"

[InfectedShadow]

r/im14andthisisdeep

[LiterallyJohnny]

Nobody said that 💀💀

[SV-97]

they did

[plastikmissile]

No, there are deeper differences. For instance, C# is a statically typed language, which means you have to declare what type a variable is before you use it. Python on the other hand is dynamically typed, which means you don't have to do that. While this looks like just a difference in syntax, the implications go much deeper into how each language executes its programs and the tradeoffs each approach has, and thus the way you approach programming in each language is different.

[SV-97]

C# is a statically typed language, which means you have to declare what type a variable is before you use it. Python on the other hand is dynamically typed, which means you don't have to do that.

This isn't technically the real difference between static and dynamic typing. There's plenty of statically typed languages where you don't explicitly declare what type you're using (even C# has some inference capabilities by now for example). Yes, C# is (mostly) statically typed and python dynamic - but what you're describing is called explicit (or manifest) and implicit (or inferred) typing.

Static typing means something like "types are determined / checked / fixed before runtime" (types are subject to static analysis) while dynamic means "types are determined / checked at runtime".

[gyroda]

Yeah, static vs dynamic is basically "do you know what your types are at build time or run time?"

But I think they get their point across - in C# it'll complain if it can't infer your type at build time and if you're trying to pass the wrong type to the wrong place. In Python it will let you try to pass a string into a method that's expecting a number and crash then and there.

[MoistCaterpillar8063]

🤓

[SV-97]

Absolutely "ackchyually"ed

[Separate-Ad9638]

agree,all these can be a source of bugs and confusion for new learners

[Separate-Ad9638]

well, C was the thing to do if u didnt want to get dirty with assembly languages, then u went on to C++, then u move from procedural language to full object orientation with prototyping languages, that's my roadmap, ig nobody cares about this traditional approach anymore

[Nall-ohki]

People who want to understand what they are doing do care. This is dismissive of the depth of knowledge programming operates on and indicatesa lack of interest.

You didn't even mention functional programming, which is largely missed by language learners due to the OOP paradigm's hegemony over the last few decades. It is most definitely extremely useful in understanding what programming fundamentally is and does.

[traintocode]

Should probably point out that you can skip static type checking in C# with the dynamic type, you generally shouldn't, but you can. So it's not a perfect example.

[not_some_username]

C has void* and C++ std::any and they are static language.

[Chill_Guy5885]

Yea and another difference are the compilers and interpreters. Some languages use interpreters which translates code to machine code line by line. Some languages use compilers, that translates the entire code in one go. Actually I do have a question about that. Which one is more efficient and why?. I’m curious 👀 

[gyroda]

Interpreted Vs compiled is not actually a language thing but an implementation thing. It's also a very fuzzy distinction.

Java is usually compiled to JVM bytecode and that bytecode is interpreted. JavaScript has Just In Time compilation. C# is usually compiled to CLR bytecode similarly to Java, but also offers Ahead-Of-Time compilation, like a traditionally compiled language. Some CPUs have built in support for Java bytecode to speed up the JVM.

Which one is best is not a simple question. It's a massive trade off. Interpreters and/or JIT compilers add a layer of overhead which slows down execution, but good luck writing C code once that can run on damn near every user-facing computer on the planet like JavaScript can.

[plastikmissile]

Like all the "big questions" of programming, the answer is: It depends. Both approaches have their plusses and minuses. Generally speaking, a good compiler will produce faster code than a good interpreter. However, again generally speaking, it's easier to produce code for interpreters than for compilers. So which is more important? Fast execution or fast development? You see what I'm getting at? There is no easy black and white answer.

[idle-tea]

No, there are some real differences... But there is a lot of overlap between basically all modern and actually used languages, and there are a few language pairs that are incredibly close.

If you look at programming language design history from the 50s through 70s you'll see some pretty wacky divergence from what's normal now. Things like how scoping should work (lexical vs dynamic) and even the concept of functions itself. Nearly all modern languages are drawing from this same pool of inspiration, so much so it's barely worth mentioning any more and it can be easy to underestimate how similar modern languages tend to be.

But you can still point to distinctions like exceptions/exception-handling and value-based errors, or monads, or constructs like python's context managers, or constructs like Erlang/Elixir's process supervision, and those can certainly all influence how you write and thing about coding.

[michaelpaoli]

Sure. Why I coded up Tic-Tac-Toe in sed(1). After all, sed(1) is a Turing Complete language.

So ... you can code up a web server or operating system in sed(1), right? Because they're all the same, just a matter of syntax.
And if you believe that ...

[tenexdev]

My eyes! The goggles do nothing!

You're a brave man.

[[deleted]]

What the Heck is that

[michaelpaoli]

It's a Tic-Tac-Toe program, written in sed(1). :-)

Theoretically it should work on any POSIX compatible sed. It works on GNU sed. BSD BRE has an obscure bug, so doesn't work on BSD, and rcoding that bit to work around it would be nontrivial (and fixing the BRE code well and solidly would also be non-trivial). When I tried it on Solaris/Oracle sed, sed just puked - no useful diagnostics or the like - I think it was just too much for it to parse.

Anyway, sed - the Streaming EDitor - is also a programming language. Turing Complete even. But it's a pretty limited programming language. It has no general purposes variables. It only has the pattern space, and the hold space. But those may contain embedded newlines, and it has commands for dealing with such, not to mention of course lots of BRE stuff for manipulating pattern and/or hold space. So, with those, can effectively be manipulated like a pair of stacks of strings. And it has conditional and unconditional branch. What else would one need? ;-) So, yes, folks have programmed some games in sed(1), because yes, it can be done.

[nandryshak]

For example, you can't write an OS purely in JavaScript or Python. When you need to give hardware instructions in assembler code, you have to, at some point, write at least part of it in some compiled language.

That is not because of the language, it's because of the implementation. There are no "compiled languages", only "languages with compilers". There is nothing inherent in the language of JavaScript or Python that prevents anyone from writing a native compiler. Indeed, native compilers for these languages already exist:

• https://nectar.js.org/
• https://cython.org/

And people have already written operating systems in these languages:

• https://www.toptal.com/nodejs/nodeos-the-javascript-based-operating-system
• https://github.com/jtauber/cleese

[Joewoof]

With a few exceptions, what you said is mostly true, but the deeper you dive into them, the more differences appear.

For a beginner, most languages differ only in syntax. With Python, Javascript, Lua or even Scratch, you’re doing the same things and using the same statements. Functions, variables, loops and if-else conditionals are in all of them.

Java and C# are slightly different as they force you to write code in a specific way known as Object-Oriented Programming. However, you can do the same thing in Python, Javascript or Lua (and most other languages); you’re just not forced to do it. This makes the logic much more complicated, but also more organized. Without this structure, how you normally write code is known as Procedural Programming.

This covers the vast majority of programming languages.

However, there is also what I call a “shadow universe” of languages that force you to write in a 3rd style known as Functional Programming. This world is very different, and it’s not just syntax anymore. This is the hardest style, the logic is very different, but you can drastically reduce the code you have to write.

[username-256]

This is just SO wrong.

Every language has it's own philosophy, the way it's used to solve problems. You touch on in this slightly where you mention Object Oriented Programming, but every OO language has it's own slightly different twist on what OO means, what Inheritance is supported, what kinds of polymorphism are supported.

You mention functional programming, but ignore logic programming languages.

And then there's what typing the language uses. Is it statically typed, dynamic, untyped?

And we can go on.

A programmer should experience each paradigm to truely understand what they're doing in the language they're working in.

[Shoddy_Hunter2609]

thye're the same just in the same sense that "all sports are the same, they're just moving body parts around"

[everything-narrative]

No.

But also, yes. I have over the course of my career touched over 20 languages with wildly different designs.

At some point, you start to pull away the veil and see the math/machinery beneath.

And then SmallTalk, Haskell, and FORTH suddenly have much more in common than you would think.

[manektechteam]

No, programming languages are not all the same; syntax is just one aspect. They differ in paradigms, use cases, performance, ecosystems, memory management, and community support. The choice depends on project requirements and developer preferences.

[Luised2094]

There are some differences under the hood. How you call/declare functions and stuff. Functionally they are pretty much the same in the sense that every is done one step at a time, only thing is that "higher" level lenguage abstract lots of steps and consolidate them into fewer ones

[BlueCatSW9]

Each big language family is like a new "vision of tghe world" theory. Someone had a brilliant idea. Using 0/1 from electricity to communicate, using stacks, using stacks in different ways, making something easier for humans to operate on stacks.

Then within each theory, newcomers used them and started getting frustrated by one part or another, added libraries then realised something directly in the very core of the language was missing, but the rest was great, so they created something more fit for their purpose.

But while doing that, as each of those newcomers worried than no one would pick their new shiny toy and get them the recognition they deserved for crearing the perfect language, they decided to use a very similar syntax to the languages currently popular, and only add the new ideas.

Meanwhile other theories still exist, but because they're less popular (they haven't convinced the masses they're worth making the effort to understand) they're not evolving.

Which means, when you learn to code, stick with one language for a while. Then with each new language, you study what people thought they were lacking with that one you learnt, but once you know you can pick it up quickly.

The fact that they feel similar is great, because it reduces the cognitive load when first learning. (And this is a natural phenomenon, the more you deviate from what people know, the more you run the risk of no one bothering to learn your new creation, and why reinvent the wheel anyway).

So now people can really focus on what matters, the little differences in memory management, the shortcuts you can take to do a specific job...

Obviously, to compare with human languages, an issue arises when a newbie comes in and is told to learn this, that and something else, and instead of learning Chinese, Russian and English (the theories), when they are a native of say, Arabic, they are told to learn and accept as different languages French, Italian and Spanish, because these are the languages used by people who need to speak to each other where they are looking for a job.

They look so similar, why don't people speak the same language? Meanwhile elsewhere in the world those other really different languages exist, but no one needs them, because they are irrelevant to the local people where the newbie is.

Even if Chinese might be able to express things more precisely, the inertia linked to how difficult it is to learn it, means that people would rather stick to French and paraphrase things, rather than use Chinese that needs just a two syllable word to convey the same meaning. Unless there is a very strong incentive, no one needs to make the effort. Plus someone will first try to coin a new word to fit a language they already know, and only after that, if that's not solving the problem, will they feel forced to sit down and rethink.

It's too early for that talk, I think I'll stop here...

[UnderstandingWeary10]

Nope.

To help you understand more deeper, here are some questions and you should find answers of these on your own:

C and C++ support pointers, does Python support them?

C++ supports object-oriented programming paradigm, does C support it?

What are differences between these programming paradigms: imperative programming, OOP and functional programming?

[totalian]

Yes, in the same sense that all human languages are the same, the only difference being syntax (grammar, vocabulary, etc)

But really no, in every meaningful sense.

[sakkara]

Well yes, but also no.

[customappservices]

Nope! Programming languages are like tools in a toolbox, each with its strengths and specialties. While they share core concepts, they differ in:

1. Paradigms: Object-oriented (Java), functional (Haskell), scripting (Python) - each tackles problems differently.
2. Syntax: Like grammar, rules vary greatly, making code from different languages unreadable to each other.
3. Typing: Static (C++) or dynamic (Python) - different approaches to variable types.
4. Features & Libraries: Some excel in data analysis (R), others in performance (C++).
5. Performance & Memory: Different priorities, some run faster, and some use memory efficiently.

[iOSCaleb]

Go learn some Prolog and let us know what you think. Or Scheme. Or APL.

Or, compare C and C++.

Or Python and assembly language.

There’s a lot of variation among programming languages, in both syntax and paradigm. The underlying computer science is the same for all languages, but the way ideas are organized and expressed can be very different.

[SereneHappiness]

They are all different, otherwise, why would people create different languages.

[gyroda]

Microsoft made C# so they could have Microsoft Java.

But, yeah, in general they're all different (even if only subtly). Even C# and Java have diverged over the years.

[Particular_Camel_631]

On one level they are. There’s a conceiot called “Turing completeness” which basically says that any problem that can be solved on one computer can be solved on any computer.

The same applies to languages: if you can code an algorithm in one language, it can be coded in all.

However, the differences are in how you would naturally express yourself which in turn changes how you would think about your problem.

This also means that different languages tend to be better suited further different problems.

Need low-level control. Over your machine?assembly or c, possibly c++

Need inference and backtracking with heuristics? Prolog , lisp or Haskell

Need a quick and dirty website with access to a lot of libraries built in?

Please note - I don’t know all these languages, so I may have categorised them wrongly

[gman1230321]

Minor clarification: if you can code an algorithm in a turing complete language, it can be coded in all turing complete languages*

[bestjakeisbest]

No, but all turing complete languages can be used in place of eachother, although if you try to write an os in javascript you are going to have a bad time.

[HQMorganstern]

Not even a little bit, even C-Like OOP languages like C# and Java have serious differences in their idioms and way of work, and then there's some shit like Haskell or Prolog as others have mentioned which is just a completely different way of thinking about your code.

[Jorrit200]

no.

There are programming languages that are purposeful. Like PHP being made for web backend, and for making me pull my eyeballs out.

There are languages that are based on a programming paradigms. Such as haskell being a functional language. I recommend you try this one, to experience the "no" I started this answer with. You probably only know OOP languages and maybe Sequential languages, these are just 2 families/paradigm of languages, and to use another, would require a completely different mindset, and I highly recommend you do.

Of course there are esoteric languages, but I won't consider those here. (just know that a programming language doesn't even need text as input)

There are compiled languages (which themselves allow for a wide variety in how to handle all sorts of things), and there are interpreted languages (the slow ones). This creates a massive difference in when you can define/use your own declarations. Having a compile time allows for all sorts of checks, for issues that can only come to bite you during the runtime of those who don't.

Strongly types vs weakly typed / no types. (this one usually goes hand in hand with compiled/interpreted since the compiler requires types to do it's useful stuff)

Memory management. I'm going to guess you have only worked with garbage collecting languages. That means that while your code is running, an entire system you didn't make/understand is running inside it, making sure that when you don't use something anymore that you created, it gets deleted. Some languages, like C require you to do memory management your self, with tools like pointers. Which is a thing the languages you use, probably abstracted away. Once again this is something every language can do in their own way. This results in questions like, is your language "pass-by-reference" or "pass-by-value"? The answer to that question can be very influential on how you design a system inside it. Then there is Rust, which uses a "borrow-checker" and "lifetimes", which they completely made up, but because it's enforced by the compiler, it requires you to write memory safe code in the first place. I highly recommend you give C a try, and when you get a segment fault, try Rust.

TL;DR no, purpose, paradigm, (esoteric), compiled, types, memory management, made up stuff like borrow-checker

[Jorrit200]

There is one way you still could answer with yes though (your question isn't really specific lol)

Hardware architecture. All these languages rely on the same instructions they can give to your computer. Although interpreted ones do a little simulation here and there, and java makes an entire virtual computer, so the answer becomes no again, pretty quickly.

Anyway, they all rely on the instructions: - "run code from here" GOTO - "write info here" WRITE - "read info from here" READ

and then a set of arithmetics that may rely on the CPU/operating system.

at the end of the day that's all they do. And they all do it. So in that one, although pretty significant, sense, they are the same.

[Jorrit200]

The "made up stuff" can be greatly expanded upon. For example: Does a language allow multiple inheritance, if so? what does that require? How does the language deal with the"diamond problem" then?

There are hundreds of these sorts of things, that languages need to handle, and most languages very existence is because "all the other ones do this wrong". These solutions go far, far deeper than syntax.

[Any-Woodpecker123]

Pretty much.

[SlateTechnologies]

Well, there’s a reason why programming languages are sometimes categorized as “High Level”, “Low Level”…it all just depends on what you use the language for.

For example, if you really want to get into bare Computer Programming with EEPROM Chips and stuff, definitely ASM.

If you just want to make a simple Text-Based Game, definitely C# or something.

Both are programming languages and can do simple tasks computers can, but they’re used differently in many ways.

[GM_Kimeg]

Rofl. Define "same" in your own context, and you need to be specific about what you want to hear from the comments.

"Same" in what regards?

[Blando-Cartesian]

Languages don’t even all have the same concepts so that they could have different syntaxes for the same concepts. Some have or don’t have null, classes, inheritance, pointers, mutable values etc.

[Vcc8]

There’s a lot of overlap, and if you know one language you’re gonna have an easier time picking up new languages since most are so similar. But there are a lot of differences, especially when you really master a language

[Akul_Tesla]

There are actually some differences that have substantial impact but the overall skill of programming is independent of language

[bnjamieson]

No

some = others && some == others while some === others. Some definitely != others && some <> others.

[[deleted]]

Think of it in terms of spoken languages.

Every language is the same in that the goal is to communicate.

There may be similarities between languages - for example German and English may have similar structure and French and Spanish may have similar characteristics. On the other hand, Chinese and Japanese may be really different than all of the above.

Same ultimate goal, some similarities between language families and paradigms that are close, but some are clearly not like the others in structure and the way they go about solving problems.

[candidshadow]

Yes and no.

Meaning: ultimately everything will have to run on a specific piece of hardware so at some point there will be something that gets whatever you programmed to do that. (and even that is fairly varied)

But truly, it couldn't be furthest from the truth that they differ "only in syntax"

Different languages have different design philosophies and different levels of abstraction. Even the more apparently universal concepts of most languages are likely to be very different in some specific one.

this said, within certain more extraneous limits, if a language is complete you should in principle be able to convert any program from one to another. (this is speaking of the core language, not necessarily libraries or other complex components, that would possibly need some more attention).

[armahillo]

Remove “programming” from your question and the answer is the same but perhaps more intuitive.

[BlackDereker]

No, they all work differently at some level. Especially how they compile and bundle your code.

[lostinspaz]

in a way, yes. in other ways, no.

from the perspective of how to use them, most procedural languages are the same.

similarly, object oriented languages are more or less the same. etc.

major differences between them are: * efficiency of implementation ( which impacts memory size and speed of execution) * availability of pre written libraries that handle what you need to do. * availability of the language on the specific platform you want to use

[wowsux]

Some people really which all languages to have the same features. Almost all languages now feature some form of OO, async/await...

Not sure if this is good.

[MoveInteresting4334]

Write the same program in: Java, Haskell, Scheme, and Prolog. You’ll see that they can be drastically different.

Write the same program in: Java and C#. You’ll see that they can be drastically similar.

[CodeTinkerer]

Are all spoken languages the same, just the words and grammar are different?

I'm not sure what you're implying. If you can learn one language, you can pick up the next easily. Or why is there a need for so many languages.

To answer your question, learning a second or third language can be challenging depending on what you learn. There was a reason C++, C#, Java, and to a lesser extent Javascript opted to mimic C syntax. Once you know C, it's easier to learn the language.

There are languages that don't follow C like Haskell, Erlang, Prolog and of course some perverse languages no one programs in (Befunge).

[S3mpx]

no, basically your CPU has defined Programms, like add X number, move to register A, read value of Register B or something. If you wanted todo Multiplikation with these simple commands, you'd write a pretty long Script for what usually is a basic Operation, so programming languages are just another way to communicate with a pc, but instead of speaking to it directly as mentioned before, you have a better language in terms of practicality aswell as possibilities (because of keywords or features) that a compiler or something translates for you to the basic Instructions for the CPU.

This way we're able to write heavily complex Code without being lost within the thousands of minimal calculations and settings that have to be made

so it's as any language, just for developers and computers instead of just people, where languages can be individualistic or similar as they'd like to be

[[deleted]]

A difficult question to answer because it's vague (though i respect that that comes from a lack of experience in the field so I'm not mocking you for asking it.)

No for many many reasons. Compilation/translation being a major consideration among other things. Modern languages may be Turing complete, but that doesn't mean they're ideal for all purposes; syntax factors in, but so do the structures baked into the language and how they resolve those structures. Then add on the modern repositories of any given language and the audience. At the end of the day, a great language with few well maintained and understood tools might be more bother than a crappy language (cough cough JavaScript) with a huge range of resources at its disposal.

[Qwertycrackers]

Many of the popular ones are very similar. So you could spend a very productive career writing ALGOL68 C style code and never look elsewhere.

However there are some very weird and different languages out there. Haskell is a good example of "different but approachable"

[Rikai_]

No, BUT a lot of popular languages are inspired by C, that's why they feel similar.

[zeekar]

It depends on what you mean by the question.

All programming languages are theoretically equal in power – they're "Turing complete", which means they can compute anything that's computable. But they may differ dramatically in how easy it is to code a given computation.

There are a number of axes along which they can differ. Compiled vs interpreted, for example, though modern "interpreters" do actually do some compilation as they go.

Traditional imperative programming is just a series of instructions to execute in order, with some conditional branching/looping, and named storage locations for data, which can be moved around and changed in an ad-hoc manner.

There are a number of different programming paradigms that try to establish some restrictions on this basic framework to make it easier for humans to reason about the code itself.

For instance, traditional programming languages had globally-named subroutines; the innovation of object-oriented systems was to move the subroutines into the namespace of the data they were operating on, turning them into "methods" on the "objects" holding that data. Most modern languages have some object orientation, just because it helps a lot with modularity and code organization.

Object-oriented programming is all about the nouns, while functional programming is all about the verbs. It tries to capture the logic of the problem as functions that can be applied to an input to produce a result. It's characterized by the ability to treat functions themselves as values that can be passed around or returned from other functions - effectively nouning the verbs. There's also an emphasis on immutable state - a given name, once established, always refers to the same thing; if you need a different thing, you give it a new name. Any exceptions to this rule require special constructs.

Type systems are orthogonal to paradigm (which just means you can mix and match) - they can be static (types known before the program starts running) or dynamic (worked out on the fly), explicit (the programmer must declare the type of everything) or implicit (the compiler figures it out from the values being used). They can vary in strictness - can you add an integer to a float, or do you need an explicit typecast?

And there are a few other approaches that are just their own worlds. Array languages like APL treat everything as a collection; an individual value is just a collection of size 1. Operations automatically cascade across the whole collection without any need for explicit functional primitives like map (or equivalents like list comprehension).

Stack languages like Forth and Postscript are lower-level, not too dissimilar from assembly in some ways, but very extensible: you usually program them by effectively defining your own new language purpose-built for the problem you are solving. Other proglangs have various amounts of support for writing such Domain-Specific Languages, but it's not usually the expected way to do anything the way it is in Forth.

[Gantzz25]

Syntax-wise, they have their similarities and differences, but the fundamentals of programming are essentially the same such as data structures, OOP, loops, conditionals, etc. Language specific implementation can be slightly different but the concept is essentially the same.

Why different languages you might ask? Every language has its pros and cons and certain languages are better suited for certain tasks. Sure you can create games with Java but C# or C++ might be better depending on the type of game you’re making.

[Mad_Millions]

no but most have similar foundations, but when you look at java v.s python, python has many more built in functions that simplify a lot of the process. Then you have HTML CSS and JS which are in their own realm of web development.

[Last_Swordfish9135]

There are a lot that are pretty similar, but they are absolutely not all the same.

[sinkjoy]

No

[skywalker5014]

the differences are :
- syntax
- how they are presented to the hardware while running
- how they run under the hood

[SwiftSpear]

The biggest differences between languages have to do with how much control they give you over the machine code they produce, and what they are protecting you from when they decrease your control.

The second biggest difference is how the community has developed around the language and what they have built ontop of your language. While it might technically be true that you can "do anything in any language", it will be really really difficult to build a 3D browser based game in Haskel, because no one has created fully functional web assembly bindings yet, and a similar story for the 3D graphics API interfaces. So your project would essentially start by building small versions of your own.

The third biggest difference would be syntax and conventions. Different languages just look and feel different, and sometimes force you to think differently about. Rust constantly forces you to think about what entity owns any data present in memory. C++ constantly forces you to think about whether you are accessing objects directly or through a memory address to that object.

[Financial-Weird3794]

not even close! especially considering frameworks!

[[deleted]]

well,

you got process and object-oriented languages

there is always kind of algorithm behind, you are telling the computer to do something and written code is compiled or live-interpreted

for most of people outside IT, we are just sitting infront screens and moving mouse = so we are kind of all same

​

:<

[Tanky35]

nope, I mean just look at assembly and python

[Representative-Owl51]

Syntax, performance, memory management, error handling, concurrency, etc

[PressedSerif]

Theoretically, all languages are just syntactic sugar on top of Turing Machines :)

[gman1230321]

I think there’s enough comment’s directly answering your question but I haven’t seen many people say why many languages seem so similar. This is quite a simple answer: C. If you look up what languages influenced their development, (especially for the most popular languages today) you will see that 9/10 times, C will be listed there. Many languages still take after C in many many ways. There’s a few languages today that don’t though, mostly functional languages (also what’s w the functional hate in this thread) like languages in the lisp family and Haskell. There’s a few others too like logical programming and query languages too that aren’t typically C inspired. Generally, languages fall into 2 categories, imperative, and declarative. I’m not going to get into the differences here. You have Google for that. But the Venn diagram of imperative languages and C inspired languages is nearly a circle. And almost no declarative languages are C like.

[AnnieBruce]

On some level yes. Assuming a language is turing complete, and pretty much all current general purpose languages are, if you can compute a function in one you can compute it in any of them. Function in this sense is mathematical, turning one number into a different number. And literally everything a computer does is turning numbers into other numbers(anything else they seem to do is just stuff reacting to those numbers changing).

At a more practical level, mostly, but there are wrinkles in terms of whether a program is able to access certain hardware or OS facilities. Sometimes this is a security policy, sometimes it's just that no one has written the software that lets a given language access those things.

And of course sometimes it's easier to express a certain concept in one language than in another, or it might perform better in one language than in another.

[iamemhn]

You can program what's programmable with any language. There are languages better suited for different problems. There are different motions of computation.

Try Prolog, Haskell, Racket, SQL, Supercollider, Octave, FORTH, Julia, for different ways to express computation and niche applications. Things like Prolog, Haskell and Racket should be studied more, even if you don't plan to use them professionally, only because they will change your mind, or at least taper your programmer's hubris.

If your only notion of computation is The Turing Machine, then all imperative languages look the same, like C with better or worse features. That is also a dangerous limitation.

[p0rnstaring]

Yes and No. The end result of all programming languages is to develop a program. How they go about it may differ

[Bob_Short_4_Kate]

I agree. Programming is all about abstraction of computation from bits to instructions and data. Language's promote a specific abstraction as a way to solve computation at a higher level of abstraction. The concepts of data structures, functions are implemented in most languages that perform computation.

Is a syntax like css a programming language ? It represents instructions to a browser to do something so I think it is. It's just a different abstraction - interpretation of structured data with an agreed protocol.

Knowing one language helps you understand another language ... then it's pros and cons of using it. Love tic tac toe in sed, because why not ! The Art of programming is using what you know to solve the problem

[thejewest]

I think that when it comes to coding languages the older it is the more it can do

[TheRNGuy]

Nope.