3w ago

More code = more better

94 comments

The advantage of that last approach is that it has side effects and cannot therefore be optimized out by the compiler.
- That’s only one advantage. In theory it does not necessarily terminate, so that’s another one.
  
  In ~~theory~~ hypothesis
  To get pedantic, you'd have to test that out a whole bunch before even coming close to theory level, lol!

undefined

function myFunction() { try { x = new Random().nextInt(); if (x != 10) { throw "not 10"; } else { return (10) } catch(err) { myFunction() } } } x = myFunction()
Commit notes: Added error handling
- Returning 10 instead of x when x finally ends up being 10 really ties it together.
  
  I'm glad you noticed. That was my favorite part too.
- SyntaxError: Unexpected token 'catch'
  
  Coding on mobile is hard

For a time on Reddit (some years ago when I still used it) there was a trend of finding the worst way of implementing is_even(x: int) -> bool. My contribution to that was a function that ran Ackerman(x,x) flipping a Boolean at every iteration, and check if it was true or false at the end.
It works btw, I will find the proof later
- I would love to see the implementaion.
  
  The implementation is not very exciting, I capture a variable in python. It could have been done more cleanly.
  
  The proof is this. But, I could have made mistakes, it was many years ago.
  
  Note that in python you'll never be able to run is_even(5) the stack cannot handle it
  Edit: daaaamn, that variable is ugly as hell. I would never do things like that now.

The compiler will optimize it anyway. /s
- You jest, but you aren't wrong. At least if we are talking about C, C++ or Rust. https://godbolt.org/z/oPPfdfcf5
  .NET compiler is weak when it comes to optimizing your code; I assume Go's is as bad.
  
  Technically yes... But I think he was more making the excuse for the gore "from the goresmith's perspective."
  And I'm not sure if the compiler in any language would change a random check function... The others are a possibility.
- Not sure about the last one though. The other two are trivial to optimize away.
  
  An infinite loop canot be ruled out in the last case, so a compiler couldn't optimize this away without potentially changing the program behavior.

How about
x=x-x
x++
x++
x++
x++
x++
x++
x++
x++
x++
x++
- Freshman year of college doing assembly programming, I spent a while figuring out a "programmic" way to solve a problem, trying to wrangle labels and gotos. My friend came in with essentially this but as lookup table. It blew my mind.
  It was then that I learned to trade space for complexity.
- This is actually a valid brainf*ck program, but it results in 19, not 10.
  
  How so? It’s only 10 increments
- Make sure you initialize x with x=x/x-x/x for better precision
  
  What if it’s already 0?

That's not even enough to get you a job these days.
You now have to use:
cpp

do { x = reinterpret_cast<int>(AI::Instance().ask("Do Something. Anything. Be efficient and productive. Use 10 tokens.")); } while (x != 10);
- This isn't just a function, it's a bold restatement of what it means to write code — a symphony of characters, questioning the very nature of the cutting edge language models that I want to beat with hammers.
- You’re absolutely right! Who sets a variable these days without running it though a LLM?
  
  Great question!

I once was helping to organize the testing of town-level algorithmic competition for school students.
The competition had one entry level issue that was basically solvable by reading the question properly, recognising that it's just multiplication of two numbers, and writing the simplest app ever.
And there was one student who passed the automatic tests. We had to read the code too for the protocol, just to make sure there was no cheating.
We looked in the code. What? Why? It had two nested for loops and a++ inside. When we understood what's going on we couldn't stop laughing for like solid ten minutes.
- Multiplication is just repeated addition :) glad it worked for the kid, despite the... inefficiency.

What is the value of x in the Good example before the loop?
- Doesn't matter, it's 10 after the loop.
- An int. Value doesn't matter because it's overwritten.
  
  Not in this case. First, i is declared and assigned a value of 0. Next, x is declared and assigned a value of -i or -0. On the first loop iteration, i will decrement to -1, perform the conditional check, then execute the loop body which will assign x to -i or -(-1) or positive 1, and so on.
  The only time a variable is created without a value is if you declare one without assigning a value like with
  [int]i;
- If this is JavaScript, it would have a value of -0, which is actually valid and works the same as normal zero thanks to type coercion. I think the only difference is some methods that detect if a number is negative will return true instead of false, but otherwise, JS treats -0 the same way as 0
- 4

It would get you promoted at Twitter, where lines of code is the productivity metric.
- If only I could measure the quality of my paper purely by word count...
  I thought "a a a a a a" x100000 was thought-provoking and well tested.

Probably Microsoft: You’re hired! Go work on GitHub
Context
- I'd say Meta hiring someone to work on WhatsApp. Man, is that piece of software crap... Every update, a new UI bug/glitch appears

Oddly enough, out of all of these the one the compiler has the best chance of optimizing out is the last one
- Not if Random writes to global state, that's a side effect that must be preserved
- What?
  First one is optimized obvious.
  Second one optimizes to x = 10 via constant propagation.
  Third one first unrolls the loop, propagates constants including booleans, and then eliminates dead code to arrive at x = 10.
  The last one cannot be optimized as “new” created objects that get used, nextInt() changes the state of those objects, and the global state of the random number system is impacted.

Wants to be Pro but doesn't even do it recursive...
- undefined
  
  function foo() { x = new Random(); case (x = 10): return (x); default: foo() }
  
  What unholy mix of languages is that? It is dominated by a blend of javascript and python, but with notes of something exotic. Maybe algol? or vhdl?, there is to little to tell.
  Impressive, someone write up a spec and publish it to the esolang wiki.

Now write a function to unroll the while loop to "optimize it for the compiler"

 undefined

    
 x = (function(){
return 10
})

Or something like that

Is this typescript?
- Could be Java.
- Seems like normal js?
  
  Js is Math.Random. and NextInt() is a java method.

Something like
undefined

int *a = new int(10) Int*b = null While *b !=10 { b = rand(); a=new int(10)} Return *b
I haven't coded recently enough in c/c++ to remember syntax but the concept might work eventually if you're lucky and have enough memory... Might need a time variant seed on the rand()...

bad but more chaotic
you want to be punk rock not blues or jazz

x = -i;
Do many languages let you do that? When it's in front of a variable I would've expected it to be a subtraction operator only and you would need to do x = -1 * i;
- In most languages I've seen - is both a unary negation operator and a subtraction operator depending on context. So it would negate an integer literal or a variable in this context.
- Personally I would expect it to behave the same in front of a numeric literal and in front of a variable. I do think most languages do that, but I haven't actually tested that many and could br wrong.
  
  Pretty much all languages do that. It's a very basic language feature inherited from basic maths notation. Same as x - y subtracts y from x in pretty much any language that supports operators.
- I just tested it in PowerShell. Works fine
  undefined
  
  $i = 1 $x = -$i $x
  Outputs -1
  
  Works fine in any language I ever used.
  I'm honestly quite surprised that this very basic language feature is even a matter of discussion here.
- Why would they not let you do that? I honestly don't know a single language that wouldn't let you do that. Same as basic math notation allows you to do that.
  x = -i
  is a totally valid mathematical equation.
  For the downvoters: Find me a single language that supports operators but doesn't have an unary minus operator
  
  It's a valid mathematical notation, sure. But there is an implicit understanding that the - in this case is making a number negative rather than subtracting (or, an implicit subtraction from 0).
  With the way negative numbers generally work in binary there would be much different ones and zeroes stored behind the scenes, so handling that would have to be pretty intentional.
  That said, I did just try it in Java because that's what I work in normally and I swear I had a gotcha with that. But it worked fine as far as I can tell.
- But of course -- It's just flipping around the -= operator!
  
  Nope, it is not.
  undefined
  
  x = 5 i = 2 x -= i // x => 3
  while
  undefined
  
  x = 5 i = 2 x = -i // x => -2
  x=-i is the unary minus operator which negates the value right of it. It doesn't matter if that value is a literal (-3), a variable (-i) or a function (-f()).
  x-=i is short for x = x-i, and here it's a binary subtraction, so x is set to the result of i subtracted from x.
  
  That only works if x is already 0
  If i is 10 and x is zero, yes, x -= i would have a value of -10. If x was 5 from something else previously, x-=i would end with an x value of -5.

x = printf("one + nine");

Can someone make it an async function?

it takes two instructions to materialize a constant in risc-v. X64 has LEA.
Risc-v is better!

94 comments