News for hackers. Stuff that matters.
Re:The responsibility we have as software engineers by arcticbull on Sunday May 24, 2015 @02:08PM (#9596996)
I think for most decent engineers, if you have a small group of good ones, no matter the time pressures they'll deliver you something half decently architected -- most likely with understood compromises. Where things start to take a turn for the worse is when more people pile onto the codebase without the context to know what the trade-offs were or where the load-bearing paint is, get in, make changes and get out. Now nothing makes sense.

In order to safely make changes to any one part of a codebase, an engineer needs to understand how it all fits together and have all that context in their head to ensure changes don't have unintended consequences.

There are design patterns that make this easier of course and less error prone, but there's no enforcement at compile time, and with people coming and going it all goes out the window.

I think we can solve a lot of these problems with much, much stricter and smarter compilers. Eventually, I hope we'll all be writing software for which the compiler will be able to tell you authoritatively you've written the thing you set out to write and there are no bugs. As software complexity grows, no one or two people will be able to keep a whole understanding of the system in their heads (already true a most of the time). It follows for me that the only way to confidently make changes to a system you don't understand is to automate that understanding.

That's why I love what Rust stands for. It's a first step to be sure. However, it makes the assertion that the only way to allow people to reliably develop software they don't understand is to have the compiler 'understand' it for them (I use understand loosely of course).

Re:The responsibility we have as software engineers by mdup on Sunday May 24, 2015 @02:26PM (#9597054)
Before Rust, it could be said that Haskell has the same philosophy of ensuring almost everything works at compile-time.

Anyway, I hope for a future where programmers will be able to specify all contracts, invariants, etc. in code, and have them be checked upon compilation. And not only for "smart" programmers, but the pretty bad ones, too.

Re:The responsibility we have as software engineers by javajosh on Sunday May 24, 2015 @04:53PM (#9597545)
>I hope for a future where programmers will be able to specify all contracts, invariants, etc. in code

Theoretically is this even possible? We simulate this with tests, and code-coverage analysis, but in the end all programs deal with unknown inputs, by definition.

Re:The responsibility we have as software engineers by sirseal on Sunday May 24, 2015 @07:57PM (#9598039)
There's certainly limits. Compilation-time type safety can only guarantee the absence of certain errors or presence of certain behaviours. Any question that can be reduced to the halting problem is something that cannot be automatically verified. However, there's lots of interesting and useful stuff that is not reducible to this problem. Such as "is this input really an integer?" (cough cough, dynamic languages)
Re:The responsibility we have as software engineers by Retric on Sunday May 24, 2015 @08:15PM (#9598083)
This is a really old idea that does not increase productivity.
Re:The responsibility we have as software engineers by jerf on Sunday May 24, 2015 @08:32PM (#9598126)
This is a really old idea that turned out to be harder than it looked, and require more computational power to be available to programmers than has generally been available. It has also required that this be available for long enough that it could build up a head of steam as people built up libraries that could be used to do real work and build runtimes that were strong in practice as well as theory.

Past failures can not always predict future failures properly in a Moore's Law regime. For instance, as everyone knows, tablet computing is a totally stupid and repeatedly failed idea, except, iPad. Computer vision is a complete waste of time, unless you have GPUs sitting around that can chew through billions of operations for cheap. Etc.

This "old idea" is getting somewhere now. It's only early days.

Re:The responsibility we have as software engineers by ArkyBeagle on Sunday May 24, 2015 @09:06PM (#9598196)
I don't think languages can be smarter than the people who use them. Maybe if we ran the tape again this time, Ada would win. But I doubt it.
Re:The responsibility we have as software engineers by Dewie3 on Sunday May 24, 2015 @02:59PM (#9597161)
> However, it makes the assertion that the only way to allow people to reliably develop software they don't understand is to have the compiler 'understand' it for them (I use understand loosely of course).

More like have the compiler make sure (and let it be able to make sure) that you didn't screw anything up. You still have to understand ownership and lifetimes, so I don't get what 'understanding' you're offloading.

Re:The responsibility we have as software engineers by arcticbull on Sunday May 24, 2015 @03:27PM (#9597274)
What I meant is that I see increased compiler validation the future of software development -- not that Rust is there, just that it's a step in the right direction. I'd love a world where I can safely make changes to trunk features and the compiler would validate that there are no unintended consequences or side-effects.

I think this is important because it addresses both the need to move quickly and the desire for responsibility.

Re:The responsibility we have as software engineers by codygman on Sunday May 24, 2015 @06:13PM (#9597831)
These are the reasons I advise using Haskell for startups. If you make everything validated (or much of it) at compile time you can move very quickly.

There's also the feeling of the code writing itself. In some places you can literally put in different functions until it typechecks which is great for exploring a problem domain.

In the future I hope to be able to recommend Idris as well.

Re:The responsibility we have as software engineers by angersock on Sunday May 24, 2015 @05:34PM (#9597710)
So, the problem with this stuff is that mere additional compiler passes and better type systems are not how we get "responsibility". That's just a red-herring.

It's as though we said "Yes, the next generation of calipers will add an additional factor of ten in precision to our machinist's work and so increase our responsibility!"...and then those machinists go on to build gas chambers.

We cannot confuse the quality of the tools with the broader notion of ethics and responsibility, even if it's the only thing we have actual control over.