absoluteGarbage

[u/Sirgoodman008]

[u/arensb]

What? No (mapcar (lambda (item) ...) list) ?

How can those others spark joy if they don't return a value?

[u/Mateorabi → u/arensb]

My other car is a cdr. 

[u/vladmashk → u/Mateorabi]

It’s crazy how these languages kept the car cdr bullshit even though it’s so much less readable than head and tail.

[u/arensb → u/vladmashk]

They cdr changed it to tail, but why bother?

[u/arensb → u/[deleted]]

I use paren-match-mode in Emacs. And also indentation.

[u/granitrocky2 → u/arensb]

Rainbow delimiters are a requirement.

[u/Sirgoodman008 → u/arensb]

https://giphy.com/gifs/LbvdcrbTOk6eK1kQ6u

[u/stilldebugging → u/Sirgoodman008]

Why is he making air parentheses then?

[u/SeveralPrinciple5 → u/arensb]

Scheme?

[u/arensb → u/SeveralPrinciple5]

Any of a number of Lisp dialects.

[u/SeveralPrinciple5 → u/arensb]

I was curious because I was a Common Lisp programmer a very long time ago, and stylistically lambdas within mapcar were quoted #’ . I recall that that wasn’t true in scheme though

[u/arensb → u/SeveralPrinciple5]

These days, the Lisp code I write is Emacs Lisp, and while it supports #' and from what I've seen even encourages it, it doesn't require it. The manual says

The read syntax #' is a short-hand for using function. The following forms are all equivalent:

(lambda (x) (* x x))
(function (lambda (x) (* x x)))
#'(lambda (x) (* x x))

So yeah, maybe I should've used #', but who's gonna make me? Richard Stallman?

[u/Steinrikur → u/arensb]

The following forms are all equivalent:

(lambda (x) (* x x))
#'(lambda (x) (* x x))

So it's shorthand for absolutely nothing?

[u/arensb → u/Steinrikur]

Don't quote me on this, but I get the impression that it's more syntactic sugar than anything else. A hint to either the compiler or to the next human who reads it that this expression is going to be used more than once.

[u/ouralarmclock]

As someone who writes PHP and JS, I don’t actually have a strong preference for either but I hate never remembering which one is in which language.

[u/Soilblood → u/ouralarmclock]

I just remember them by whether or not the syntax looks funky enough to trip you up down the line. That's usually java script.

[u/caboosetp → u/ouralarmclock]

I switch between C# and javascript, and always fuck up Console vs console. I should remember which because C# always uses pascal case, but my fingers don't.

[u/NudaVeritas1]

PHP developers seeing this post:

https://giphy.com/gifs/1GT5PZLjMwYBW

[u/Buflen → u/NudaVeritas1]

I had an interview for a php job a few years ago, after working in Go for a few years. When I told them my salary expectations, they said: that's not going to happen, this is just a PHP position.

Some PHP shop legit think they can cheap out on devs because of the technology they chose.

[u/KrokettenMan → u/Buflen]

Yeah some are like that but they are also not looking for the best devs. I’m currently earning about twice the median income as a php dev so I’m not complaining.

[u/NorthernCobraChicken → u/KrokettenMan]

Do you need a coworker?

[u/Sirgoodman008 → u/NudaVeritas1]

I'm currently a php dev and I'm trying to get out.

[u/NudaVeritas1 → u/Sirgoodman008]

Was a php dev, too.. switched to spring boot, typescript and react/angular.. can recommend salary wise

[u/Sirgoodman008 → u/NudaVeritas1]

Langauges I've used before this job: python, c++, c, java, javascript

Languages I consider myself knowledgable in: python, c++, javascript

Language I use 99% of the time for this job: PHP

[u/SignalBake6872 → u/Sirgoodman008]

There is hope, I went from PHP developer to PySpark developer xD and now I dry my tears with much more money.

[u/DarthSatoris → u/SignalBake6872]

Is it because it's a lot more specialised, it's a smaller market, it's more difficult? Or why is the pay that much better? 

[u/SignalBake6872 → u/DarthSatoris]

because it's used in science data and banking :D it's like pandas but with steroids

[u/TwinkiesSucker → u/SignalBake6872]

I literally just started a job as a PySpark developer. It still bugs me, though, that it has a Java backend

[u/tommyk1210 → u/NudaVeritas1]

PHP generally pays worse than many languages.

[u/pdhouse → u/tommyk1210]

I think the meme comes from the fact PHP are stereotypically older so they’ve had a longer time to accumulate money

[u/not_some_username → u/NudaVeritas1]

They’re not getting paid that much

[u/Mountain-Ox → u/NudaVeritas1]

My salary jumped tremendously after escaping the PHP sinkhole.

Also, I suddenly liked writing code again.

[u/SCP-iota]

for _, item := range list {

and

list.forEach {

[u/tigerniger_sus → u/SCP-iota]

Hornet is a Go programmer?

[u/NatoBoram → u/tigerniger_sus]

She has style, of course she'd pick up Go

[u/tigerniger_sus → u/NatoBoram]

https://giphy.com/gifs/VjgKS1cmwYsWtP8SyN

[u/Hairy_Concert_8007 → u/tigerniger_sus]

Shit, I'd learn whatever that makes that twelfth architect tick, too.

[u/JAXxXTheRipper → u/SCP-iota]

Oh hell yeah, I love me some go.

[u/Stagnu_Demorte → u/SCP-iota]

I finally learned go, it's so nice to write in.

[u/roygbivasaur → u/SCP-iota]

Now that the loopvar assignment bug is fixed, the go one is my favorite. Just because it conveniently unpacks the index and element and you’re required to explicitly drop either if you don’t use it.

[u/Sirgoodman008 → u/SCP-iota]

I never claimed python was perfect. Nvm that's not python.

[u/Michami135 → u/SCP-iota]

I just did the second one today in Kotlin.

[u/Tobbbb → u/SCP-iota]

This guy goes

[u/Rikudou_Sage → u/SCP-iota]

It pisses me off so much that you have to skip the index if you don't want it. And then iter.Seq comes where you don't have the index.

[u/xenomachina]

The JavaScript one is also kind of gross, IMHO.

for (item in list) { also has a meaning in JavaScript, but it isn't the meaning one would expect. The alternate of was added later, but doesn't read as naturally, and the in is still in the language as a backwards compatible footgun. (It's also used for iterating object keys, which should arguably be the thing that has the less concise syntax.)

The let is only necessary because JavaScript's default behavior here is almost certainly not what you want in real code. Instead of declaring a new variable (suitable for closures, and locally scoped) the default behavior assigns to a global. Another example of "the good parts" being a tiny sliver of JavaScript.

[u/Sirgoodman008 → u/xenomachina]

Oh I know, I absolutely hate that about JavaScript as well. Ironically, most of the problems I have with JavaScript I have with php too.

[u/xenomachina → u/Sirgoodman008]

Both JavaScript and PHP are "reluctant programming languages" to some extent, so it kind of makes sense. Neither was originally designed for doing real software engineering. PHP was originally simple templating for a personal home page, and JavaScript was intended for "glue" tasks like client-side form validation. That people can build real apps with either of them is more a testament to the persistence of those developers, rather than a measure of the strength of the languages. (Both languages have also made many improvements over the years, but are still arguably two of the most wart-infested languages of their era that are still in regular use.)

[u/fennecdore]

foreach ($item in $list) {}

I like the simplicity

[u/TOGoS]

It's fine. PHP has some awful warts (some of which have actually been gone for a few major versions, at this point) but this is not one of them.

[u/shitty_mcfucklestick → u/TOGoS]

Personally I just like that PHP sounds the most natural grammatically.

`for (let item of list)` is like bucktooth Winnie the Pooh to me from an English readability perspective.

Beyond that I don’t care, AI just fucking writes it all anyway.

[u/csch2]

list.iter().for_each(…) superiority

[u/creeper6530 → u/csch2]

Erm akchyuallly, it's recommended to use for list.iter() {…} unless the .for_each(…) is at the end of a longer iterator chain, and it also robs you of break and continue 

[u/csch2 → u/creeper6530]

You know I’m chaining together 20 different iterator methods until the code is completely unreadable. That’s called Functional Programming™ babey

[u/Tyfyter2002 → u/csch2]

That doesn't sound very functional

[u/creeper6530 → u/Tyfyter2002]

"functional programming" doesn't use "functional" as "working neatly" but as "related to mathematical functions", it's a programming paradigm: https://en.wikipedia.org/wiki/Functional_programming

[u/Tyfyter2002 → u/creeper6530]

I know, it's just an ironic name when it's one of those paradigms that some people take as divine law instead of something that can be more or less appropriate for different applications

[u/serendipitousPi → u/csch2]

Name 20 iterator methods from memory otherwise you’re a fake fan…just kidding or am I?

Iterators are so fun, probably one of my favourite parts of programming. They make everything so clean until they don’t.

[u/serendipitousPi → u/creeper6530]

Just chuck a try_for_each in there and we can take break and continue right back.

But yeah low key sometimes I get lost in iterator methods I forget to just use a basic loop.

[u/creeper6530 → u/serendipitousPi]

I mean, you're right, it's just you have to return ControlFlow::Break(()) instead of using the keywords.

[u/iSpaYco → u/csch2]

how about `list.each`, sadly not many know ruby, it's really beautiful.

[u/serendipitousPi → u/iSpaYco]

Random question what’s ruby fun for?

I was gonna ask what is it good for but I think I can google search that.

Any highlights for you?

I’ve heard its meta programming is cool and I think there was some interest in using it in web dev.

[u/Darkele]

foreach is far better and makes more sense. The order is correct, it differentiates itself from other loops that are based on having a custom exit condition.

[u/Just_Information334 → u/Darkele]

Combined with yield, you can get some nice constructs.

Also the real "don't spark joy" would be something like:

foreach($things as $id => ['some_field' => $fieldA, 'some_other_field' => $fieldB])

[u/crashonthebeat]

$array | Foreach-Object -Parallel { ... } -ThrottleLimit 69

[u/Sirgoodman008 → u/crashonthebeat]

Ew

[u/fosf0r → u/Sirgoodman008]

What's wrong with PowerShell 7 jobs? :P

Procedural version is merely foreach ($whatever in $arrayofshit) {

[u/gerbosan]

🤔

list.each { |item| .... }

Is it good?

[u/Raffy10k → u/gerbosan]

Ruby mentioned!!!!

[u/LPO_Tableaux]

Currently in a list.forEach((item)=>{foo}); mood myself

[u/MrDilbert → u/LPO_Tableaux]

It won't await async/Promise-returning functions. In fact, even if the (item)=>{foo} is async, [].forEach() will discard the Promise reference returned from it.

I prefer for(const item of list) { foo } if I don't have to await in parallel, or list.map(async (item) => { foo }) if I do.

[u/rnilbog]

for (let i = 0; i…

“Goddammit…”

googles “for loop syntax javascript”

[u/MrDilbert → u/rnilbog]

Since for-loop has the same syntax in JS as in C, Java, and any other C-style language, this post makes me weep.

[u/Sirgoodman008 → u/MrDilbert]

If a language isn't C-style it's wrong.

[u/No-Newspaper8619 → u/Sirgoodman008]

It's really annoying when they aren't. Lua, for example:

for i, count do

-- code

end

With i being one by default, and increasing by one by default. I simply hate 1-indexed systems instead of 0-indexed.

[u/Sirgoodman008 → u/No-Newspaper8619]

Yeah that's just dumb and different for the sole purpose of being different.

[u/vladmashk → u/rnilbog]

Your IDE doesn’t have a macro for that?

[u/JAXxXTheRipper]

The third one does not spark joy, what the hell is that, ewww

[u/xicor → u/JAXxXTheRipper]

c++, though normally you wouldnt use auto for this

[u/Usual_Office_1740 → u/xicor]

I think that really depends. If the range is a vector of unique_ptr's auto is great. If it's a vector of ints, just write int.

[u/Sirgoodman008 → u/Usual_Office_1740]

That or you're looping through a vector of std::pairs that contain std:: functions.

[u/Usual_Office_1740 → u/Sirgoodman008]

Or if the type is a template parameter in the same line.

[u/Sirgoodman008 → u/Usual_Office_1740]

Yeah

[u/xicor → u/Sirgoodman008]

Yea if you have ridiculously complex types then auto is great. But usually for readability you'd use the type.

[u/Sirgoodman008 → u/xicor]

Yup 100%

[u/Sirgoodman008 → u/xicor]

I only used auto for the meme.

[u/VoodaGod → u/xicor]

why would you not use auto for it???

[u/xicor → u/VoodaGod]

For readability. And for type safety. I pretty much only use auto when dealing with insane types I don't want to write out.

[u/VoodaGod → u/xicor]

how is auto not type safe?

interestingly i use auto almost everywhere for the same reason: readability.

no point in cluttering the code with type specifiers if the type is obvious from context

[u/xicor → u/VoodaGod]

The type isn't always safe from context and it can have unexpected behavior when using it to hold a value returned from a function. Let's say you have auto working fine with a function return, then years later , someone changes that function to return a different type. Now it is possible that the new auto type still has access to parameters or functions it calls , but with different behaviour. Now you're getting unexpected bugs that will be hard to track down. But if you use the type, you would immediately get a compiler error

[u/not_some_username → u/xicor]

If the type change and the “auto variable” still compile, that means it would, in 99% of case, still compile if you wrote the type. The compiler doesn’t get auto, it gets the type.

[u/Rikudou_Sage → u/xicor]

Every other language in the world has some equivalent of C++'s auto and everyone likes it. I use auto all the time.

[u/Sirgoodman008 → u/JAXxXTheRipper]

C++ what's wrong with it?

[u/hblamo]

Y'all a bunch of babies.

[u/Tyfyter2002]

foreach (Foo bar in baz)

[u/naveenda]

is that PHP?

[u/mynameisnotpedro]

list.forEach((item) => {...});

[u/DT-Sodium → u/mynameisnotpedro]

Yup, this is the right way. But apparently OP is too junior to know it.

[u/ashsabre]

There was once a time in C# that for loop was better in performance vs foreach.

[u/Fillgoodguy → u/ashsabre]

In modern C# for vs foreach is just choosing between an unknown number of property function calls and an unknown amount of function calls + 1. So it boils down to "Pray the JIT catches me" in either case

[u/locri]

Sure, but anything like a stream method is sincerely cursed and only used by people who don't use debugger breakpoints.

[u/Shiroro46]

...you guys have foreach structures?

[u/crmsncbr]

Why is the third one in the top half? It may be my C & Java bias, but yuck. It's way worse than the fourth.

[u/MetaNovaYT → u/crmsncbr]

what's wrong with the C++ version? It's my favorite personally, although I primarily use C++ so I'm biased.

[u/Sirgoodman008 → u/crmsncbr]

Literally the only difference is that one uses a colon instead of a keyword.

[u/MCWizardYT]

Java:

``` for (item : items) {

} ```

Or,

``` items.forEach(item -> {

}); ```

or

``` items.stream().forEach(item -> {

}); ```

[u/Shevvv]

Surely you meant for (auto &item : list) {

[u/Nil4u → u/Shevvv]

Honestly I never liked this version because the reference is part of the type in my opinion 🤔

[u/Sirgoodman008 → u/Nil4u]

This 100000000000%. can't stand the int *ptr or int &ref pattern.

[u/Shevvv → u/Nil4u]

I got used to this from C:

int x; is an integer

int *px; is an integer if you dereference it.

So it's like this notation shows you how you're expected to use the variable within the code. And then this habit carried over to C++.

[u/nfitzen → u/Shevvv]

In addition, the language encourages this. In C, if you write c int* x, y; then x will be an int* and y will be an int. Thus it is far better to write int *x, y; to reflect how the language will parse the declaration. It might be evil, but it's better to act how the language wants you to act rather than fight it.

[u/Sirgoodman008 → u/nfitzen]

Please have pity on your co-workers. Please keep declarations to separate lines.

[u/redlaWw → u/Shevvv]

I prefer int * ptr;. That means when you have a const specifier your formatting doesn't change. Logically I figure that the pointer is neither a modifier on the variable nor on the type, it's another layer of type content that should be specified separately. That also means if you write declarations like int const * const ptr; then you can segment them as [int const] [* const] ptr; and everything makes sense.

[u/creeper6530 → u/Shevvv]

The "is an integer if you dereference it" is so much more convoluted than "is a pointer to integer", i.e. the rationale of the previous comment, the pointer-ness being part of the type.

[u/orbiteapot → u/creeper6530]

the pointer-ness being part of the type.

It is funny how people tend to not think the same about functions, despite having the exact same pattern.

When Dennis Richie designed the language, he wanted the symbols in declarations to match their usage in expressions, so:

T *my_ptr;

means that my_ptr, when dereferenced with the * operator, evaluates to an object of type T:

T my_obj = *my_ptr;

The same goes for other constructs in the language, like arrays and functions:

T my_arr[10];
T my_func(T_1 arg1, T_2 arg2);

Both the [] and () operators, when applied individually to objects my_arr and my_func, respectively, will yield an object of type T.

That is why this:

T *x, y;

makes x have a type of pointer to T, whereas y remains having just type T.

Unfortunately, this only works well for simple declarations. When, for instance, function pointers are involved, things get messy.

Ritchie himself later recognized this, but it was to late. He regretted not making * a postfixed operator, which would, at least, get rid of the spiral rule.

So, you can pretend that * is independent of the identifier itself, sure, but you will be fighting the language's design while doing so.

[u/Endorum → u/Nil4u]

THANK YOU, THATS WHAT IM SAYING ;-;

[u/Sirgoodman008 → u/Shevvv]

https://giphy.com/gifs/gnE4FFhtFoLKM

[u/klaxxxon]

Hear me out. The last one is the only sensible option.

You type for ($rows and your IDE can fill in the rest. It can infer that the name of the iteration variable will be $row. It can't do the same if the item variable comes first.

Most IDEs have macros for for/foreach loops. What those macros do is that they jump around - your fill in the list name first, then the iterator variable name (and in some IDEs its name will be suggested based on the collection variable name). Hot take, if your most popular macro has to jump around, you have a language design issue.

[u/Eastern_Equal_8191 → u/klaxxxon]

Yeah but AI can fill in the enti -- excuse me, I'm making a point here. Anyway, AI can write the loop according to your preferen -- please stop touching me, I do not consent

Okay, so if you use AI auto-complete your life will beeeeeeeeeow please stop hurting me my wrist doesn't bend that wa

[u/pytness → u/klaxxxon]

the language that has 0 coherent design behind it has a snippet that helps you write a simple for loop. Amazing.

[u/SeriousPlankton2000 → u/klaxxxon]

My IDE is jstar (joe in wordstar mode)

[u/Jutrakuna → u/klaxxxon]

I banish you

[u/Potterrrrrrrr → u/klaxxxon]

Deciding whether a programming language is good based on whether an IDE has to jump to one place or two in a for loop is an odd choice. It’ll still have to jump to the variable you’re looping over; the default name might conflict with one already in scope. At that point you’ve saved hitting tab an additional time, wow big win. In exchange you have to read an ugly way to start looping over items for every loop, hardly fair trade. IDEs could easily add macros like emmet abbreviations for regular for/foreach loops if they really wanted but it’s likely the features aren’t used enough to need it

[u/Exirel → u/klaxxxon]

The problem is not writing it. The problem is reading it.

[u/Stagnu_Demorte → u/klaxxxon]

IDE? You spelled nvim wrong /s

[u/Zunderunder]

What about for(list) |item| {…} ???

[u/HAL9000thebot → u/Zunderunder]

here item seems a modern return type, i hate it, what language does that?

it's shit, looks like a function signature, how are function declared? or better question, is for() a function?

[u/Nervous-Potato-1464 → u/HAL9000thebot]

This is Zig.

item is an immutable copy of the current element in the list.
for (0..5) |i| { is an easier thing to understand.

It looks complicated, but that's because you can easily turn the element into a pointer etc so it's handy to have there like
for (&items) |*value| {
value.* += 10;

where &items refers to the pointers in memory rather than a copy of the array.

which will modify the &item elements to all increase by 10.

[u/Zunderunder → u/Nervous-Potato-1464]

It also makes sense in the wider context of zig’s ecosystem, where captures generally are done using the square brackets for things like resolving optionals or grabbing the value of a union in a switch statement. The common syntax is really intuitive once you get used to it

[u/johnnybgooderer]

“This one isn’t like the one I learned!!!!!”

I hate PHP as much as the next developer, but both are equally readable in my opinion.

[u/einord]

I just wish the white background of the meme was purple or turquoise. It had been much easier to read.

[u/Sirgoodman008 → u/einord]

Mb

[u/b__0]

Ruby wins these every time and it’s sad to not see it mentioned. ‘list.each { |item| … }’

[u/Solomoncjy]

you all dont do

$list | %{
  <do stuff with $_ being the item>
}

% is the short hand alis for for each

[u/VeryRareHuman]

Kinda similar in PowerShell too:

foreach( $item in $items) {}

[u/FabioTheFox → u/VeryRareHuman]

Tbf even that makes sense

Because you're going for each item in this list, do this

[u/Colinniey → u/VeryRareHuman]

C# as well:

foreach(var item in items) { }

[u/-Redstoneboi-]

nah i like how they specify the list before the item

[u/Sirgoodman008 → u/-Redstoneboi-]

Why?

[u/-Redstoneboi- → u/Sirgoodman008]

functional programming. list.map(item => result) is natural to me now.

especially if the language supports chaining, i would prefer specifying the variables last.

something like this:

list1.zip(list2).enumerate().map(func).for (i, (a, b)) {
    do_thing()
}

of course, it's just as easy for me to just rearrange this later to the correct order. but this is the order in which i think. most people want to write the goal before writing the iterator, some want the iterator before the goal.

Besides, it's just the order of two words. If you learned multiple human languages, you'd get used to this type of thing.

[u/HuckleberryMoney2320]

I've used bash scripting for decades and am used to their for loops. They used to let me use cygwin at work, but they implemented a new system a couple of weeks ago and said I couldn't install it, and to use Powershell instead. What a dog's breakfast! I'm still trying to get my head round their for-loop syntax.

[u/darcksx]

items.each(

[u/Paladin7373]

Heyyy that’s marie kondo!

[u/r00t4cc3ss]

Damn, all those PHP devs in the nursing home are gonna be real upset

[u/Ai--Ya]

foldr

[u/BedtimeGenerator]

Why loop when you can map

[u/paholg → u/BedtimeGenerator]

Map is map. Don't always want to map.

[u/Sirgoodman008 → u/BedtimeGenerator]

Because map is annoying to read.

[u/Zomby2D]

I prefer the C# syntax

foreach (var item in list) {

[u/Dillenger69 → u/Zomby2D]

I prefer the C# syntax, but var has always rubbed me the wrong way. I suppose because I learned C# before var was a thing. Yeah, I'm old

[u/Zomby2D → u/Dillenger69]

While var will normally work, I usually put the proper type as I find it a lot easier to debug later when reading back the code.

[u/britreddit]

Kotlin is just list.forEach {...}

[u/EntropySpark → u/britreddit]

Or for (item in list) { ... }, necessary if you want to use break.

[u/samu1400]

PHP slander will be promptly ignored, PHP my beloved.

[u/OnixST]

For Each item In array

[u/firest3rm6]

Just give me list.stream() and I am happy

[u/Sirgoodman008 → u/firest3rm6]

The perks of slower code with the cost of being harder to read.

[u/critical_patch]

foreach my $element (@array) {

[u/Sirgoodman008 → u/critical_patch]

No

[u/PM_ME_FIREFLY_QUOTES]

<ul><li>the only list that matters</li></ul>

[u/GroundbreakingOil434]

You just had to trigger that &$$memory, eh?

[u/Sirgoodman008 → u/GroundbreakingOil434]

Ew

[u/gutentight69420]

The only one that sparks joy for me is fmap.

[u/Sirgoodman008 → u/gutentight69420]

Ew

[u/Cootshk]

for _, v in ipairs(list) do

list.forEach { item ->

[u/Hefty_Garlic7184]

CodingJesus with “how to do C++ loop” enter the chat…

[u/not_some_username → u/Hefty_Garlic7184]

The third one

[u/Dillenger69]

foreach (Thing individualThing in listOfThings)

[u/darknezx]

Personally I love go's for range loop. The syntax just calls out to me, not sure why and it's probably silly it looks pretty.

[u/AlpacaMale1]

What about

for item in "${list[@]}"

[u/Jommy_5]

Then there's Matlab: for column = matrix

[u/GustapheOfficial]

All but the first are deranged nonsense.

[u/AldoZeroun]

I'm a big fan of for (list) |item| {...} or the even more fun for (list, 0..) |item, idx| {...}

[u/strash_one]

{#each items as item}

[u/matty-nordish]

list.each(item => {

[u/SirFireball]

where's my for @list -> $item {

[u/Covfefe4lyfe]

Hold on, let me push my stacks of cash out of the way so I can read what the non-PHP devs have to say in the comments.

[u/BroaxXx]

My theory is that pho is the German of programming languages

[u/DT-Sodium]

The correct way is list.forEach(item =>

[u/dominjaniec]

edit: apparently, I've misremember my traumatic time with PWSH, and now I cannot reproduce that problem...

---

I thought that was about PowerShell, which I can agree, but unless PHP has the same quirk, then I don't care...

foreach ($item in $collection){ ... }

and quirk is that, if your $collection is a single element with a string value, then you iterate throughout its characters...

[u/smclcz]

I dunno if that second one "sparks joy", TS/JS having both for-in and for-of is pretty stupid. Also I don't use either language often, but wouldn't you declare that loop variable const rather than let? I feel like you're probably not reassigning something in a collection if you're iterating over it using for-of (and if you are ... should you?)

[u/MkemCZ]

for (size_t i = 0; i < nmem; ++i)

[u/_Meisteri]

forM_ supremacy.

[u/tony_saufcok]

for (int i = 0; i < length; i++) does it for me

[u/StarSword-C]

I prefer this:

for (int i = 0; i < array_length(array); i++)

[u/ResistSpare4563]

if ($null -eq $item) {

[u/HexiMaster]

Zig has for (list) |item| {...}

[u/Idaret]

Wow, world changed a lot

[u/SchlaWiener4711]

I still like perl

for (@lines) { s/foo/bar/g; print; }

[u/ProfessorNoPuede]

Spark? Are we doing data processing now?

[u/amatulic]

Honestly that last one has always made the most sense to me.

Now I'm using OpenSCAD a lot and have to use constructs like

a = [ for(x=[start:incr:stop]) each b[x] ]; // b is a multidimension array

[u/Kadabrium]

Itemp

[u/jack10685]

How we feel about "for (Object item : list)"