3 ms·
> Conclusion: Coderive doesn't just make loops faster—it redefines what's computationally possible on commodity hardware. I mean this as kindly as possible, bu
by MobiusHorizons 10mo ago
> Conclusion: Coderive doesn't just make loops faster—it redefines what's computationally possible on commodity hardware.
I mean this as kindly as possible, but please don’t say things like this if you want to be taken seriously. Computer languages cannot possibly change what is possible on a given machine for the simple reason that whatever they are doing had to previously be possible in assembly on the same machine.
I don’t mean to overly discourage you. Lazy execution can be very useful, but it’s also not clearly new or hard to get in other languages (although it would require different syntax than an idiomatic for loop most of the time). It may help to try to pick an example where the lazy execution is actually exercised. Preferably one that would be hard for an optimizing compiler to optimize.
I would also not recommend claiming iteration if you also claim 50ms, since that’s clearly impossible regardless of memory consumption, so you have to optimize away or defer the work in some way (at which point iteration is no longer occurring).
For these examples, I think you would just express the code as a function taking i instead of pre-populating the array. This doesn’t seem hard at least for the provided examples, and has the benefit that it can be opted into when appropriate.
- DanexCodr 10mo agoyeah. I should have been more specific that it takes an imperative-like syntax and not actually iterate it internally but takes the formula it can use to process the loop much faster. Here is an actual output too: Enter file path or press Enter for default [/storage/emulated/0/JavaNIDE/Programming-Language/Coderive/executables/LazyLoop.cod]: > Using default file: /storage/emulated/0/JavaNIDE/Programming-Language/Coderive/executables/LazyLoop.cod Testing timer() function: Timer resolution: 0.023616 ms Testing condition evaluation: 2 % 2 = 0 2 % 2 == 0 = true 3 % 2 = 1 3 % 2 == 0 = false 24000 % 2 = 0.0 24000 % 2 == 0 = true Conditional formula creation time: 2.657539 ms Results: arr[2] = even arr[3] = odd arr[24000] = even arr[24001] = odd === Testing 2-statement pattern optimization === Pattern optimization time: 0.137 ms arr2[3] = 14 (should be 33 + 5 = 14) arr2[5] = 30 (should be 55 + 5 = 30) arr2[10] = 105 (should be 1010 + 5 = 105) Variable substitution time: 0.064384 ms arr3[4] = 1 (should be 42 - 7 = 1) arr3[8] = 9 (should be 82 - 7 = 9) === Testing conditional + 2-statement === Mixed optimization time: 3.253846 ms arr4[30] = 30 (should be 30) arr4[60] = 121 (should be 602 + 1 = 121) === All tests completed === --- That is from this source: unit test share LazyLoop { share main() { // Test timer() first - simplified outln("Testing timer() function:") t1 := timer() t2 := timer() outln("Timer resolution: " + (t2 - t1) + " ms") outln() arr := [0 to 1Qi] // Test the condition directly outln("Testing condition evaluation:") outln("2 % 2 = " + (2 % 2)) outln("2 % 2 == 0 = " + (2 % 2 == 0)) outln("3 % 2 = " + (3 % 2)) outln("3 % 2 == 0 = " + (3 % 2 == 0)) // Also test with larger numbers outln("24000 % 2 = " + (24K % 2)) outln("24000 % 2 == 0 = " + (24K % 2 == 0)) // Time the loop optimization start := timer() for i in [0 to 1Qi] { if i % 2 == 0 { arr[i] = "even" } elif i % 2 == 1 { arr[i] = "odd" } } loop_time := timer() - start outln("\nConditional formula creation time: " + loop_time + " ms") outln("\nResults:") outln("arr[2] = " + arr[2]) outln("arr[3] = " + arr[3]) outln("arr[24000] = " + arr[24K]) outln("arr[24001] = " + arr[24001]) // Test the 2-statement pattern optimization with timing outln("\n=== Testing 2-statement pattern optimization ===") arr2 := [0 to 1Qi] start = timer() for i in arr2 { squared := i * i arr2[i] = squared + 5 } pattern_time := timer() - start outln("Pattern optimization time: " + pattern_time + " ms") outln("arr2[3] = " + arr2[3] + " (should be 3*3 + 5 = 14)") outln("arr2[5] = " + arr2[5] + " (should be 5*5 + 5 = 30)") outln("arr2[10] = " + arr2[10] + " (should be 10*10 + 5 = 105)") // Test with different variable names arr3 := [0 to 1Qi] start = timer() for i in arr3 { temp := i * 2 arr3[i] = temp - 7 } var_time := timer() - start outln("\nVariable substitution time: " + var_time + " ms") outln("arr3[4] = " + arr3[4] + " (should be 4*2 - 7 = 1)") outln("arr3[8] = " + arr3[8] + " (should be 8*2 - 7 = 9)") // Test that it still works with conditional outln("\n=== Testing conditional + 2-statement ===") arr4 := [0 to 100] start = timer() for i in arr4 { if i > 50 { doubled := i * 2 arr4[i] = doubled + 1 } else { arr4[i] = i } } mixed_time := timer() - start outln("Mixed optimization time: " + mixed_time + " ms") outln("arr4[30] = " + arr4[30] + " (should be 30)") outln("arr4[60] = " + arr4[60] + " (should be 60*2 + 1 = 121)") outln("\n=== All tests completed ===") } }
- DanexCodr 10mo agoYou're right about hardware limits, but wrong about what's being 'redefined.' Coderive redefines developer productivity for certain computationally hard problems to solve: Before Coderive: To explore 1 trillion cases, you'd need: · A cluster of machines · Distributed computing framework (Spark/Hadoop) · More time for setup With Coderive: ```java results := [1 to 1T] // Conceptually 1 trillion for i in results { results[i] = analyzeCase(i) } // Check interesting cases immediately ``` It's not about computing faster than physics allows. It's about thinking and exploring with ease without infrastructure constraints.
- DanexCodr 10mo agojust as a virtual machine is not an actual machine, what I meant about iteration is being a 'virtual iteration'.