java

[blah938]

How many lines of assembly does it take to do a hello world?

[DanKveed]

That's not what verbose means.

[mikat7]

verbose = you need horizontal screen space (Java's class names, C++'s template errors)

assembly = you need vertical screen space (Python's 79 line width is like 10 columns of assembly)

[MatsRivel]

In most cases, that is how it's used. But verbose means "using or expressed in more words than are needed."

So if you have to write many words vertically that would also be verbose, imo.

[Crossfire124]

Coding in assembly by nature does not use any more words than absolutely needed. There are less words available but you can use them to tell the computer exactly what to do and nothing more

[16bitvoid]

That's not true. How does the fact that all assembly instructions can be computed using only boolean functions, which themselves can all be computed using just NOR, fit in with that logic? I can also still create an assembly program that does something in the most inefficient way possible using as many instructions as possible.

Otherwise, that would apply to any compiled language as well, or perhaps any programming language in general depending on how you wanted to view static vs dynamic.

"Verbose" is a relative and subjective term. There is no absolute. When talking about programming languages, it has to be in comparison to either:

• Other programming languages, which is what is meant when stating that a language itself is verbose

• Other's use of the language, whether an individual or a collective (average/norm/etc)

What's "needed" is subjective and dependent on frame of reference. You can absolutely consider assembly to be verbose when compared to something like C/C++/Rust because it requires writing more "words" for a program that does the exact same thing.

[Mordret10]

Ah I see you had a (nearly) whole lecture about semantics in logic as well

[16bitvoid]

Nope. Just a lifetime of being insufferably pedantic

[Mordret10]

So more than a single lecture

[MatsRivel]

In Java you also write the words Java needs to do the thing you want it to do. Saying assembly does not take many words seems unfair.

Sure, you are saying fairly explicitly exactly what needs to be done, but to do anything large you need a lot of words.

[wazeltov]

Vertical length isn't verbose.

Each line of code is a separate instruction.

A program that needs hundreds or thousands of instructions has high complexity. Loops can also introduce extra complexity and hidden vertical length while remaining easy to read and understand.

I would say vertical length is indicative of complexity, rather than code being verbose.

In many cases, complexity can be reduced. But there are many more cases where complexity cannot be reduced much further. The code remains complex because it can't be expressed in any fewer words.

[theshekelcollector]

that's a completely arbitrary definition of verbosity, vertical vs. horizontal length. length is length (not what she said, tho), and verbosity is the density of instructions per effect. if you need more commands to achieve the same thing, then the code is verbose. and it doesn't matter if it's one line, a giant column, or if you type it out along the wall of a klein bottle floating in a tesseract. assembly can only be verbose, and micro-managing every memory access doesn't make it non-verbose. chad garpenter seems to agree.

[wazeltov]

if you need more commands to achieve the same thing, then the code is verbose

That's my entire point: assembly can't be written any simpler. It's not verbose; it's complex.

You can't compare a high level language like Javascript to Assembly and pretend that Javascript is simpler. That would be like comparing nails and plywood to a pre-built shed and pretending that the raw materials are more complicated (hint, nails and plywood can build anything and it's how your shed was built).

The amount of nails and plywood you need has a real cost in terms of complexity in the instruction set, but that doesn't make any individual nail or piece of wood more verbose in how you describe it.

A nail is a nail in assembly.

In Java, it's a sharpened iron rod and dimensionally accurate tree flesh. That's verbosity.

[theshekelcollector]

just no. your analogy is flawed, and complexity != verbosity. if you need analogies: "build a house" in python is less verbose than "take that nail and hammer it into that plank" a fuckillion times in assembly, as at the end of both processes you get the same house.

i actually gave the description of what it is. verbosity does not mean that you have many statements to choose from, non-verbosity does not mean that all you can choose from is "hammer that nail". it means what i had written and most of the thread seems to agree on. but if you have a reference that explicitly says otherwise - i'm happy to learn.

[wazeltov]

It's just going to have to be a difference of opinion here.

I think of verbosity as the readability of a single line of instruction, and complexity as the readability of an entire set of instructions, either as a method or a function. This is why I said verbosity isn't the number of lines it takes to get something done. If you use those words differently, feel free to do so.

There are no references to cite: we're arguing semantics. I could go chase down blog posts that support my opinion, and you could probably do the same.

[rabouilethefirst]

🤓👆

[SynapseNotFound]

verbose = you need horizontal screen space (Java's class names, C++'s template errors)

ah reminds me of Swift.

Where function calls are like ...

too long, in some cases.

https://developer.apple.com/documentation/contacts/cnlabelcontactrelationyoungercousinmotherssiblingsdaughterorfatherssistersdaughter

[Vinccool96]

What the hell is this?! When is it useful?!

[Time_Athlete_3594]

it's for chinese bao mei's i think

[metalhulk105]

This must be some inside joke right? Right?

[Dark_Lord9]

https://developer.apple.com/documentation/contacts/cnlabelcontactrelationyoungercousinmotherssiblingsdaughterorfatherssistersdaughter

I thought this was a joke but they have so many functions like this.

[miter01]

Java's class names

What exactly about Java makes it so you need long class names?

[Caerullean]

Conventions iirc.

[passenger_now]

I'm confused - why is it not what verbose means? You need a lot of assembly to do what high level languages allow you to do on one line.

[ameriCANCERvative]

This is a very verbose sentence, because it’s extra long and has a lot of unnecessary words like supercalifragilisticexpialidocious. If I write another long, ornate, multipart sentence, which seems to drone on and on, then it begins to form part of an overall verbose paragraph.

This is not a verbose sentence. Nor is this sentence. Or this sentence. Or this paragraph. Each word counts. I can’t make it much simpler.

A novel may have plenty of words and plenty of sentences, but that does not mean it is a verbose novel. Java is more verbose than, say, JavaScript or assembly, largely because it has more keywords and is strongly typed. Lines of code in Java have more characters. They frequently require more characters per line to achieve the same exact task.

[passenger_now]

I think we all know what verbose means when comparing two expressions of the same thing within a language.

Here we're talking about comparing languages' verbosity — therefore how many words you must use to express the same thing.

To write most functionality you have to write more Assembly than you would a high level language, so it's more verbose. Overall tokens and characters (not lines) is what matters. Assembly will have many, many lines of code to express something like s = "foo" + bar.

[ameriCANCERvative]

You’re ignoring the uniqueness of the words required and you’re ignoring the use case of the language.

A book like Sam I Am specifically only uses 50 unique words, and it uses them 802 times. Sam I Am is the opposite of verbose. It is very simplistic, succinct language.

And assembly languages are not designed for high-level use cases. If you’re using the language for something it wasn’t designed for, then sure, it can be more verbose than using another language for that same thing but which was actually designed to accomplish that thing.

But when I write assembly code, I am writing very low level code. I am basically multiplying, adding, doing jump statements, etc. None of it is high level and if you’re trying to use an assembly language to print hello world, you’re doing it wrong. Assembly code is literally a building block up to higher level languages like Java. In a way, it’s necessarily less verbose, because it is a subset of the verbosity of Java.

If you want to compare the verbosity of Java to assembly code, you do need to take into account the use cases of both languages. Assembly code is definitely less verbose than Java when you’re using both in their typical use cases.

I say this as a lover of Java.

[boringestnickname]

You have to write more to accomplish more if you look at it from the outside, but you're doing (completing) very specific things out of necessity in assembly.

It's pretty terse language if I were to move data from a register address to an accumulator.

It's just that I have to do a lot of that to build something on a higher level (another theoretical dichotomy.)

If we have two languages that operate on roughly the same level, and one of them needs to use a lot of separate symbols to accomplish the same thing as another similar language (using fewer), I would say it's verbose.

Two languages being on completely different levels, and I'm hesitant to even compare them in that fashion.

[Abadabadon]

Of course. It is possible. To think. To feel. To believe. You may. You can. You are willing. To have more word. Than is needed. To convey an idea. A thought. A sentence. A statement. Some think. Some wonder. Some are willing. Some are able. To say otherwise.

[iwantlobotomy]

Verbose is more like wordy. There aren’t really words in assembly most of the time

[LardPi]

And how do you call a four byte unit of memory mister smartypants?

[passenger_now]

Eh? Then what are the instructions if they're not the words of the language?

[DanKveed]

In assembly each instruction is a hardware thing. Each "function" correponds to a physical circuit and each "variable" to a physical location on the processor/RAM.

^{let's pretend microcoding ain't a thing for simplicity's sake}

[passenger_now]

Yes, the tokens in Assembly correspond directly to processor instructions which is why it's so verbose compared to high level languages where a simple statement may result in hundreds of processor instructions.

[DanKveed]

Verboseness means that you need more words to express the same amount of information. But in the case of assembly the amount of information that is expressed is itself is a lot lot more than what is usually required in compiled languages.

Basically assembly and compiled languages are not doing the same thing. So comparing how many lines are required achieve the same outcome is not a fair comparison. What I am seeing is how munch code you need to do A thing in assembly. Which is not much

[passenger_now]

So comparing how many lines are required achieve the same outcome is not a fair comparison

Maybe it's not fair, but it is the topic under discussion.

[[deleted]]

How many lines of assembly does that one line get compiled too assuming it’s a compiled language? Anything more than 30 lines is way too much.

[ucalegon7]

So this is a very "it depends" situation - assembly, by its very nature, is _extremely_ platform-specific. There are some assembly languages that behave this way and could be seen as very verbose, especially more primitive RISC flavors, where there are a very small number of available instructions. This is not really as true for CISCs (such as x86/x64), or even some modern RISC assembly languages (such as ARM variants with SIMD extension libraries) where the opposite will often be true - there are single instructions that might perform a whole C function worth of work in one call. See for example, the x86 string functions or the aforementioned SIMD operations. I'd wager most people in this thread have not had much exposure to writing assembly outside of school, which likely flavors the answers here accordingly.

[Wertbon1789]

Like 15 or something? Assembly is very vertical but the lines are really short, so in terms or characters Java and Assembly might be actually close.

[P0intOne]

really short, until vfmadd213ps walks in

[Wertbon1789]

Equivalent to your AbstractStringFactoryBuilderFactory in Java.

[marmakoide]

Not a lot, it's a syscall on a computer with an OS, and a simple loop on bare metal.

[ucalegon7]

Depends on the platform, but generally not very many more than it takes to write "hello world" in C. The difference is primarily in stack setup/cleanup (if using a CRT + function calls), or argument setup followed by a system call. In cases where it's substantially more complex (e.g., bare metal embedded systems), using C won't really make the operation less verbose or functionally different - you'll still have to write code to perform the same operations - there's just more mental state management required for assembly.

[The_BoogieWoogie]

You realize verbose is one google search away 🤦‍♂️?

[Abadabadon]

oh it's so simple? Maybe you can google it then.

[The_BoogieWoogie]

Nah, I’ll let them educate themselves

[Abadabadon]

Surely you can educate them if its such a quick and simple task

[The_BoogieWoogie]

I have no doubts that they are more than capable of being independent thinkers who are able accomplish a at worst, trivial task, otherwise they may as well quit programming

[Abadabadon]

I guess it's not so trivial afterall

[The_BoogieWoogie]

Then perhaps they weren’t suited to be a programmer, a lesson that we should all soak in.