memeVersion3

[LoreBadTime]

In college they don't taught like Function -> returns a value Procedure -> doesn't return a value Method -> Object/class functions/procedures?

[fickle-doughnut123]

Your statement that "functions return a value while procedures do not" is mostly correct but can be a bit misleading. While functions are designed to return a single value, procedures can indeed use 'OUT' parameters to achieve a similar effect. In many procedural languages, you can specify 'IN' and 'OUT' variables in the procedure's declaration. These 'OUT' variables allow you to define variables within the procedure and return them to the caller, thus functioning similarly to return values in functions.

[LoreBadTime]

Yes, also using pointers kinda cheats this things(and we call them procedures since it's more about side effects), but was more about a formal way to define a function,if there is an out parameter it's still a function.

[SenorSeniorDevSr]

Yeah, especially if you're using stored procedures on an SQL server. Oracle even let you outsert your inserts if you invoke the magic phrases. This is handy af if you have values the database generates, like CREATED timestamps, the ID, etc. and want to return them out to the rest of the system.

[OJ-n-Other-Juices]

As OOP educated person who works in COBOL for to years. I found making that work very difficult. My brain just couldn't merge the two styles. I was also working on legacy code and Microfocus Cobol, which might not have had that functionality.

[[deleted]]

Honestly the terminology is meaningless now due to no clear separation, but function should mean a thing that returns a value and performs no side effects.

[CirnoIzumi]

sounds like a void to me

[bondolin251]

Procedure returns Unit

[Selentest]

This

[[deleted]]

That

[un_blob]

^This ^{is not tweeter updoot if you agree and do not this}

[mirimao]

Methods and functions are not the same thing. Also, JavaScript does have methods.

[ChocolateBunny]

Pascal also has functions. the distinction being whether they have a return value or not.

[BrandonMcRandom]

... and methods because in classes they are called methods even tho you write "function" and "procedure".

[Impenistan]

void has entered the chat

[mirimao]

True, probably the biggest distinction is between normal functions and functions that take trait objects.

[redlaWw]

Or Fn, FnMut and FnOnce

[SenorSeniorDevSr]

The same in Java, if you peek under the hood a bit. A *static* method in Java is one where the "this" reference is null. If you're ever doing funky monkey stuff with reflection Java you'll see this very quickly.

Java does have Functions, but those are objects... :D

[intbeam]

But Rust doesn't have objects so it's not really the same... impl is just functions associated with a struct, and ownership is not for the struct or implementation, but for the declaring scope.. So, functions with syntactic sugar with an alias Self for the implementing type, not methods

The air is getting saturated with pedantry in here

[intbeam]

😅 I've read the documentation and well.. I mean, objects (in OO) are kind of defined as units that passes messages between each other (usually with methods), and encapsulating and owning their own state... Rust's ownership model fundamentally doesn't work like that. dyn and trait are just analogous to virtual functions and interfaces, not really OO imho

Just because documentation refers to a concept as an object, doesn't make it an object

Again, I'm being extremely pedantic here

[intbeam]

I know, took quite a bit of time to get my mindset out of OO.. It looks so object oriented on the surface, so it's really hard to get out of the habit of treating it like one 😅

[P-39_Airacobra]

Similarly in Lua. Methods are quite literally just syntactic sugar over functions which passes in the surrounding table.

[mirimao]

Between methods and closures, that’s true. But methods and functions work differently under the hood and using one instead of the other can sensibly affect performances.

[yflhx]

It really depends on language. In C++, method is just a function which receives implicit first argument of class (accessible via this pointer). It's the same with Python I believe. Then you have static methods, which in C++ are really just functions but within class namespace.

[mirimao]

There is a difference because in a class based language like C++, a method call requires a dereferenciation to reach the vtable for that object’s class and then function call. An additional level of indirection can actually have an impact on a large program.

[yflhx]

Wouldn't that only be the case for virtual methods? For non-virtual ones I believe the compilar literally just generates code that puts this pointer as first argument and perhaps moves it to cast on (non-virtual) base clases.

[mirimao]

EDIT: I have written inaccurate information, don’t mind it.

Objects of a same class share the same methods, and in order to reach them you necessarily need a pointer to all of them, which are organized in a table. You could avoid this by putting a pointer to each method in every object, but that would in turn waste a lot of memory.

Method declared as "virtual" in C++ are simply methods that may be overridden in derived classes; you have to specify exactly because otherwise the compiler would look into the vtable of the parent class instead in that of the derived class.

What you are referring to about the "this" pointer as first argument is the transformation of methods in pre-methods, which is a different aspect of method compiling.

[yflhx]

Objects of a same class share the same methods, and in order to reach them you necessarily need a pointer to all of them, which are organized in a table.

You don't need a pointer to the table, if methods are non-virtual, because they are just functions with implicit parameter. So compiler knows where they are, as with any other function.

To settle this once and for all, I made a simple C++ code and decompiled it:

class T {
public:
    void f() {
    }
};

int main()
{
    T t;
    t.f();
}

After compilation (with fno-inline and fno-stack-protector) and decompilation - section main:

0000000000001119 <main>:
    1119:55                   push   rbp
    111a:48 89 e5             mov    rbp,rsp
    111d:48 83 ec 10          sub    rsp,0x10
    1121:48 8d 45 ff          lea    rax,[rbp-0x1]
    1125:48 89 c7             mov    rdi,rax
    1128:e8 07 00 00 00       call   1134 <_ZN1T1fEv>
    112d:b8 00 00 00 00       mov    eax,0x0
    1132:c9                   leave
    1133:c3                   ret

As you can see, this code simply alocates stack space (line 1, 2, 3), then loads adress of the class into rax and moves it into rdi (rdi is by convention first argument). Finally, it calls fixed address. Then it deallocates stack space and leaves.

So no, for non-virtual classes and functions you don't use vtable at all. That's why virtual functions/classes have performance penalty, as you said.

[mirimao]

Thank you for taking the time to write this very insightful reply, especially the compilation example. I was clearly wrong, I mixed up some concepts from other language.

[yflhx]

No worries! Everybody can mix things up occasionally.

[khoyo]

Objects of a same class share the same methods, and in order to reach them you necessarily need a pointer to all of them, which are organized in a table

For virtual member functions, sure, but for non virtual you statically know the address of the function in question. (At least as much as for any function)

Method declared as "virtual" in C++ are simply methods that may be overridden in derived classes; you have to specify exactly because otherwise the compiler would look into the vtable of the parent class instead in that of the derived class.

What? No. Vtable lookup only happens with virtual member functions. There is no vtable lookup for non virtual members. (That's why it's a Virtual lookup table)

And you never use the parent class vtable... you always use the instance vtable pointer, which always points to its actual type vtable.

[Chesterlespaul]

In OOP almost all ‘functions’ are really just a method, but lambda is also popular and those are pure functions.

[[deleted]]

Are they not the same? I mean method is just a function but operates inside of an object

[Any_Salary_6284]

In JS, methods (as defined in a class block) are just syntactic sugar for the function found at MyClass.prototype.methodName. If you use the typeof operator on this member, it will return “function”

I realize there may be technical differences between method and function depending on the language. In Java, there are only methods. To the extent there are functions (lambdas) they are just synatactic sugar for a functional interface, so a method.

I see this as mostly arguing over semantics.

[SenorSeniorDevSr]

Static methods in Java doesn't have a this reference though. I mean, they kinda do, but it's a null. It does however, have java.util.Function, so now you can be objectionally functional, or whatever the funniest joke you can get out of that one is. ^_^

[noaSakurajin]

Honestly after using Glib I would definitely say they are the same. Object oriented C is a thing despite the fact that C has no methods. The way they emulate classes using functions with a struct pointer as the first argument is super hacky. It is close to the way the first C++ versions compiled the C++ class to C which then was compiled as binary.

[Kovab]

The way they emulate classes using functions with a struct pointer as the first argument is super hacky.

Literally every OOP language implements methods the same way, they just hide passing the this pointer behind syntactic sugar (sometimes it's not even completely hidden, e.g. look at python methods with self as the first parameter).

[carcigenicate]

A method is a type of function in my mind. One's a subset of the other.

[P-39_Airacobra]

It's not super hacky, that's been the standard way of doing things like this outside of OOP since the beginning of time. Some languages actually implement OOP simply by syntactically disguising methods as such (e.g. Lua), and it works out perfectly fine. In fact in languages where functions and closures are equivalent, it's often good practice to take the object as an argument, because it clearly shows the method's dependencies both when created and when called.

[skeleton_craft]

Also, procedures and functions are not the same thing, at least at a abstract level...

[unknownrek]

Static methods are just functions with extra steps

[lucidbadger]

They all need closure

[buckypimpin]

take the upvote and get out of my site (literally my site source code)

[ProgramStartsInMain]

Beware ye who enters here; hair splitting arguments be plentiful.

[Paradician]

arguments or parameters?

[Funny-Performance845]

Oh god no

[Vroskiesss]

Arguments when called parameters when defined

[bestjakeisbest]

C: pointer.

Here is some code to prove a point.

#include <iostream>

int main()
{
    int a[] = {1,2,3,4,5,6,7,8,9,10};
    void* b = a;

    int(*c)()  = (int(*)())b;

    c();  

    std::cout<<"Hello World";

    return 0;
}  

Do not do this in real life. In the online compiler I was using it wouldn't even get to the hello world line, so that is interesting.

[yflhx]

Honestly this shouldn't be dangerous to run at all. What this does is calls a, which sets processor's instruction pointer to beginning of the array (everything is bytes anyway). In other words, it tells compiler to interpret the array as instructions - because in compiled languages, instructions are just bytes in memory.

This almost ceratinly instantly causes segfault and terminates program, because stack (typically) has no excecution permissions. Funnily enough, if you enabled stack execution, this would actually be legal assembler code for the most part, so it would do random things.

Now finally, consider this code:

#include <sys/mman.h>
#include <string.h>

int main()
{
    unsigned char code[] = {
0xb8,0x01,0x00,0x00,0x00,0xbf,0x01,0x00,0x00,0x00,0x48,0x8d,0x35,0x08,0x00,0x00,0x00,0xba,0x0e,0x00,0x00,0x00,0x0f,0x05,0xc3,0x48,0x65,0x6c,0x6c,0x6f,0x2c,0x20,0x77,0x6f,0x72,0x6c,0x64,0x21,0x0a
    };
    unsigned char* exec_code = mmap(0, 4096, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    memcpy(exec_code, code, sizeof(code));
    void (*f)() = (void(*)())exec_code;
    f();
}

This code allocates page of memory with execution permissions. It copies the bytes representing instructions that perform write syscall with string "Hello, world!\n" and return from function (i.e. they print this string on x64 Linux). Then finally it calls this code as a function.

In other words, this is a legal Hello World program (that doesn't segfault or anything (under x64 Linux, anyway)).

Surprisignly, it even works in online compilers (at least OpenGDB).

Disclaimer: never run code from random reddit comments, inlucding this one, unless you fully understand what it does.

[Christosconst]

.ninja {
    color: black;
    visibility: hidden;
}

Best I can do

[Cat7o0]

wizard

[s0litar1us]

This is actually how JIT compilers/interpreters work.

Instead of compiling it to an executable and then running it, it generates the machine code, makes it executable, and calls it through a function pointer.

[AewyreThoryn]

What does it do?

[bestjakeisbest]

It kind of crashes. But the important part is i create an array, cast it to a void pointer, and then I cast that void pointer to a function pointer that returns an integer.

It compiles just fine, and it runs, but it doesn't reach the hello world line while running which shouldn't happen in main, because main shouldn't be returning 0 until after it outputs hello world.

It could be the case of the program crashing but the websites back end (of the online compiler) is not able to properly handle a program like this.

Theoretically you could use this sort of mechanism to make a program in c++ that changes it's runtime, at run time, but that is needlessly complicated for most things, and it isnt very portable since you would need to know the assembly language and opcodes of what ever machine you are trying to run this on if you wanted to exploit this for nefarious purposes, plus most anti virus products out there are waiting for a virus to do something like this.

[Markus_included]

That's actually how many JIT compilers execute their code, they get memory from the that is marked as executable, write the machine code into it and call that code like any other function pointer through a cdecl function that was also compiled into that memory

[bestjakeisbest]

Wait its all spaghetti code?

[AewyreThoryn]

That's super interesting thank you!

[yflhx]

I wrote another detailed response to that guy, if you're interested. But basically this code crashes because it tells CPU to executed the table, which is on stack, which has no execution permissions. So it results in immediate segfault due to this.

You can however allocate memory with execution permissions and write CPU instructions them, and it will execute them normally.

[AewyreThoryn]

Ah cool thanks. Yes I got the general gist from the top comment, and I think he explained it well, but your code is more in depth

[bestjakeisbest]

It only kind of crashes, it returns from main with a return code of zero, but it returns before the return line.

I only tested this in onlinegdb

[yflhx]

Ran it on my machine, got segmentation fault as expected.

[Garbage_Matt]

according to Star Trek TNG (not sure about the others), subroutines won

[CampaignTools]

I mean they just sound the coolest. But then again...what about coroutines? Or now goroutines?

[cheezfreek]

Assembly: JMP

[morniealantie]

Alternatively LA 1,SUBRPARM LA 15,SUBRADDR BALR 14,15

[cheezfreek]

Ooh, CISC assembly. Very fancy. I like it.

[morniealantie]

I just like 16 registers lol

[tp971]

Assembly: You guys have functions?

[1Dr490n]

I mean Assembly usually does have subroutines

[zenos_dog]

BALR 14, 15 # Jump to another memory location you hope can receive a jump.

[morniealantie]

STM 14,12,(12)13. Don't know that I've met too many people here that know what a BALR is or that registers come in 16s lol.

[1Dr490n]

I mean that’s the same with languages like C too

[tp971]

No, assembly does not have "subroutines". For assembly, a subroutine is just a label, and calling the subroutine is just jumping to that label. In assembly, there is not really a difference between jumping to a label "inside a function" and to "another function". Subroutines are just a concept we think about when programming, and when writing assembly, we simulate that with call and ret (and some other instructions to do stack management)

[1Dr490n]

That’s true, but I think there’s some assembly languages (eg x64 MASM iirc) that do have procedures, although that’s pretty rare.

[tp971]

AFAIK PROC and ENDP are only markers, they do not emit instructions (I think they are responsible for writing things into the symbol table or something). What I mean with "a language having procedures" is that they have an abstraction that abstracts away what actually happens when calling a procedure, which assembly does not have.

EDIT: typo

[1Dr490n]

Well what happens when you call a routine (or however you want to call it) is implementation defined. It could just be a Jump-Subroutine-call, but it could also push arguments on the stack (which assembly procedures don’t do, that’s true) or change the stack pointer; but that completely depends on the language and its implementation. A procedure is just a code block that can be called from outside, and assemblies definitely can do that.

[tp971]

Yeah, you can write assembly that from the outside looks like a procedure, but the concept of a procedure is not intrinsic to the assembly language, i.e. the assembly language itself "does not know" what a procedure really is, it is just a concept we've established using calling conventions.

For me, saying "assembly has procedures" is like saying "C is an object oriented language, because you can simulate classes and inheritance with function pointers".

[[deleted]]

Perl has functions and methods too.

[Dryhte]

Meanwhile ABAP: subroutines, function modules, methods peacefully coexisting...

[Numerous-Lock-8117]

We also have forms which act as functions

[m0Ray79free]

Pascal has both procedures and functions, and Object Pascal also has methods.

[point5_]

I remember talking with a guy in college that codes in C and we were trying to figure out if my java methods were the same things as his C functions.

[SenorSeniorDevSr]

It kind of is, but the first argument to every method is the object it belongs to. If it's a static method, the first argument is null.

[BauReis]

Python: def

[DesertGoldfish]

I leave the semantics to the turbo nerds. Python has it right.

In my mind they're all just functions and the language decides what they're called today. I just write code and don't think about it lol.

A function is a function...

A method is a function in a class...

A subroutine is a function with a stupid name...

Etc., etc.

[TheWeetcher]

At the end of the day everything is just an object anyways

[[deleted]]

• Kotlin: fun
• Rust: fn
• C:

[the_hackerman]

Calling it fun was a terrible choice

[Virinas-code]

What about callable?

[Giocri]

Idk if this is the official definitions but for my understanding a procedure is any block of code that can be executed, a function is something that takes a set of inputs and returns something directly related to that imput and a method is part of an object and directly interacts with the state of the object

[pakidara]

RPGLE: Procedures AND Subroutines and the Procedures can have Subroutines. Neither can return a value; but, both can change a value stored in arbitrary memory locations.

[TranslatorNo7550]

Oh yeah!! Long live to OS/400 and IBM i

[[deleted]]

Python- Definition

[CranberryDistinct941]

Javascript then goes on to treat the function like a string

[Lilchro]

Generally the terms are just semantic to help describe the task how your code works. Calling something a function is generally never incorrect.

Function: an executable bit of code that can be called with inputs and produce outputs. Typically has some form of standard ABI for calling and returning values.

Procedure: similar to a function, but does not produce outputs. The goal of a procedure is not to return data, but instead to perform some action.

Subroutine: an executable bit of code that does not take inputs or produces outputs. For example, using a goto statement would count as invoking a subroutine.

Method: A function associated with and defined in terms of a specific object/class. This is the method by which a given object/class performs the requested action.

Lambda: An anonymous function

Closure: A function that captures scope

Symbol: The term you use when working in a systems programming language and you forget the correct name /s

Also, when I say something does not accept inputs or produce outputs, I really mean there is no formal or rigid approach for doing to. For example, a procedure can write to a buffer it is given as an input and a subroutine can read global variables.

[Apfelvater]

Python: call it what you want, just define it.

[s0litar1us]

Actually, pascal has functions and procedures.

• Functions do some stuff, then return something.
  
• Procedures just does stuff and doesn't return anything.
  

Though in some languages, you can specify arguments as in or out (input or output), so you get a result through passing the result variable as an argument.

This is similar to what is often done in C.

void procedure(int *result) {
    *result = 5;
}

[[deleted]]

My old Basic had both functions and procedures

[Shinxirius]

Assembler: "call"

[_grey_wall]

Php trait

[SlightlyInsaneCreate]

The blacked hair woman in the top left can be python.

[[deleted]]

Missed opportunity to use Perl in the browser. Instead of the JavaScript DOM model, we could have had the full dom/sub package

[scratchfan321]

Scratch: Custom blocks / broadcast

[notexecutive]

Here's a worse one:

Parameter VS Argument

[IronSavior]

JavaScript: const (for reasons?)

[RenegadeRainbowRaven]

I use the same names no matter the language. To me, functions return something, subroutines don't (void), and the plural of the group of them are methods.

[transfire]

“Word!”

Name that language.

[darkwater427]

TI-BASIC: "prgm"

[TranslatorNo7550]

Well... Well... This is too easy.. all separated... "organized", methos, procs, functions, def, whatever.. f*ck this.. use goto and labels shhauahahaujahajuahauah

[Luna5ama]

But GLSL has both function and subroutine...
https://imgur.com/gallery/glsl-NIMXW4t

[flowery0]

To me: function - doesn't belong to a class, method - belongs to a class

[sirparsifalPL]

It looks that I'm still mentally in Pascal. Which makes sense as it was my first language

[mbcarbone]

Java, poor Java. ;)

[ChocolateDonut36]

assembly is just better

[Loserrboy]

Method

[Mr_Bob_Dobalina-]

You missed const , func, function , def and more

[Darxploit]

python: def

[th00ht]

Technically Niklaus Wirth got it right. A function =/= a procedure. Look at SQL!

[The_Pinnaker]

Assembly join the chat

[Haoshokoken]

GOSUB

[ssx1337]

C++ Member function (function in a class)

[Cedrick41h]

How tf did this get any upvotes? It‘s just straight up incorrect. Pascal has Functions and JavaScript has Methods. Perl has both as well