While you do have a fair point, I was referring to the case where one is basically implementing a map operation as a for loop.

Technically this is also possible with for loops, like with OpenMP

Compiler optimizations like function inlining are your friend.

Especially in functional languages, there are a lot of tricks a compiler can use to output more efficient code due to not needing to worry about possible side effects.

Also, in a lot of cases the performance difference does not matter.

Also surely a lot of people would know tar -Create Ze Vucking File and/or tar -Xtract Ze Vucking File

You mean that instead of having a binary blob you have a generator for the data?

Depends on how deep down the rabbit hole you want to go :p

• creating a new variable that contains the updated value
• recursion (e.g. it’s not possible to make a loop that increments i by 1, but it is possible to turn that loop into a function which calls itself with i+1 as argument)
• avoiding typical types of operations that would update variable values. For example instead of a for loop that updates every element of a list, a functional programmer will use the map function, which takes a list and a function to apply to each element of that list to create an updated list. There’s several more of these very typical functions that are very powerful once you get used to using them.
• monads (I’m not even gonna try to explain them as I hardly grasp them myself)

Dogmatic statements like this lead to bad, messy code. I’m a firm believer that you should use whatever style fits the problem most.

Although I agree most code would be better if people followed this dogma, sometimes mutability is just more clean/idiomatic/efficient/…

In functional programming, everything is seen as a mathematical function, which means for a given input there is a given output and there can be no side effects. Changing a variable’s value is considered a side effect and is thus not possible in pure functional programming. To work around this, you typically see a lot of recursive and higher order functions.

Declaring all values as const values is something you would do if you’re a diehard functional programmer, as you won’t mutate any values anyway.

Reed hucks = redux Heather net = ethernet

Oh no, strangers on the internet know I had sex and there were dog-like noises! That’s the exact same as people who know me IRL such as family or coworkers! I shall now sink through the ground in shame!

Is that just like the shared memory model of parallel computing or are there any added complications? Have you done this before? Please do share your experiences if so cause now I’m interested :p

FreeRTOS tasks are basically processes, IIRC other rtoses have similar mechanics too

if(condition) statement; Is valid in typical C-style syntax.

if condition { … }

Is invalid in typical C-style syntax

1. several languages that are still in use have eager evaluation.

2. I’m a dumb programmer. The more I need to keep implicit behaviour in mind, the higher the probability I’m writing bugs. Short circuit evaluation is an optimization technique IMO and shouldn’t be relied upon for control flow.

3. The aggressive tone you’re using is completely unnecessary and immature, so I’ll refrain from responding any further. Have a nice day.

https://en.m.wikipedia.org/wiki/Short-circuit_evaluation

Yes I am serious.

1. That’s behaviour that’s just part of language design. If you rely on it you should probably check how the language you’re using handles it.

2. relying on that behaviour sounds a lot like “clever” (read unnecessarily unreadable) code

Dot in dutch is punt

Does commercial mean closed source in this context though? It seems like a waste of resources not to provide the source code for an rtos.

Considering how small in size they tend to be + with their power/computational constraints I can’t imagine they have very effective DRM in place so it shouldn’t take that much to reverse engineer.

May as well just provide the source under some very restrictive license.

Don’t you have the code in most cases? Like with e.g. freeRTOS? That’s fully open source

Isn’t that still the same exact process as a normal compiler except in the case of embedded systems your OS is like a couple kilobytes large and just compiled along with the rest of your code?

As in, are those “crazy optimizations” not just standard compiler techniques, except applied to the entire OS+applications?