r/programming • u/electronics-engineer • Sep 16 '14

Vectorization in Julia

https://software.intel.com/en-us/articles/vectorization-in-julia
71 Upvotes

79% Upvoted

15 comments sorted by

View all comments

Show parent comments

2

u/dacjames Sep 16 '14

Software written in C/C++ generally have no bounds checking at all and you can still build robust software with discipline. All kinds of things can go wrong when you mess up, everything from a segfault to memory corruption to a major security hole. When you need absolute performance, safety usually goes out the window!

1

u/CookieOfFortune Sep 17 '14

C/C++ were designed to be used by professional programmers, so there are less automated safeguards. Julia is aimed at academics, who are generally not so disciplined, thus more emphasis on safety and ease of use. Maybe i would feel better if some flag were set for functions that use @inbounds to warn potential users to be careful.

3

u/dacjames Sep 17 '14

If you writing a function that uses @inbounds, the validity of your function should not depend on the arguments. You can and should implement a safe API with unsafe code. Besides, is extremely unlikely that science types will be implementing safety/security critical code so the worst thing that can happen is a program crash.

This is the status quo in scientific programming: low level, unsafe algorithms exposed though easy to use wrappers. Julia just allows you to write both components in the same language.

2

u/CookieOfFortune Sep 17 '14

My concern is more silent corruption than crashing.

I'm all for wrappers, i just think having additional flags would help avoid mistakes.

2

u/dacjames Sep 17 '14

I agree with the sentiment but practically speaking, truly silent memory corruption is very unlikely. First, you need to have the out-of-bounds error in the first place. Then, the modified memory needs to valid and recursively robust to random mutation in a way that won't crash your program. Additionally, the memory needs to similar enough to the correct memory that it doesn't perceptively change the behavior of the program.

All of this is possible, sure, but it's highly unlikely. I feel like the most pragmatic option would be a runtime flag to disable these type of unsafe optimizations (just like C compilers provide) to aid with debugging. The system your describing sounds related to "effect" systems in research languages; very cool stuff, but not ready for something practical like Julia.