Hacker News Reader

Comment by nextos | Hacker News Reader

I agree with his main point.

Programming will become true engineering soon. In a few decades, we will be building mainstream software with formal guarantees. And for that, there's tons of abstract algebra needed as a foundation, once you try to digest [1-6] and whatever replaces them in the future.

It's tragic most CS programs do not emphasize this a bit more.

[1] https://www.elsevier.com/books/lectures-on-the-curry-howard-...

[2] https://softwarefoundations.cis.upenn.edu/

[3] https://www.cis.upenn.edu/~bcpierce/tapl/

[4] https://www.springer.com/gb/book/9783540654100

[5] http://www.concrete-semantics.org/

[6] http://adam.chlipala.net/frap/

View on HN

In the future, I really don't think the vast majority of software engineers will need to know any abstract algebra in order to use or write software with strong formal guarantees. The history of software engineering (and most engineering disciplines in general) is a narrative in which practitioners need to know less theory as time goes on.

I expect that formal methods will become another specialization that most engineers don't need to directly work with, alongside things like cryptography and low level arithmetic.

Yes.

Nowadays it is mostly about tools/frameworks. You don't even need to master the programming language that you are using.

I work mainly with Java stack and see so many devs with 10+ years of experience who know nothing about Java internals, who know nothing about how Java's hashmap works...heck, many of them can't even explain what some _keywords_ do: volatile, transient.

Nevertheless, they 'successfully' close their JIRA tickets and deliver.

> Nevertheless, they 'successfully' close their JIRA tickets and deliver.

Leave those quotes away and I agree. If they know enough Java to finish those tickets in a way that the bug is actually fixed and the fix itself does not impose more technical debt than needed, then those developers know exactly enough java and close their tickets successfully indeed.

I wrote my own compiler for a subset of Java (including inheritance and overriding) to MIPS in uni, among the top in class, and am currently looking to compile Haskell to a very neat kind of calculus (check out "Formality-Core"). It was a really fun experience, but I feel that compilers are immensely overhyped. I guess that is because it is a hard topic and for many people, the investment is huge, so they exagerate the benefits they percieve to reap.

Being proud of understanding something or admitting that a topic is hard is all fine, but I am absolutely allergic to elitism where it isn't just. And no, in 2019, knowing all about parsing and register allocation won't unlock superpowers anymore.

That’s true. And that’s the artifact of the difference between software engineering and computer science. One can be a successful software engineer, consistently delivering useful code that just works. Does it have to be the best design and best code ever. Maybe, maybe not. Does it really matter? Maybe, maybe not. Real computer scientists would be more concerned over design and efficiency. Any important software development project would benefit from both types of professionals.

Yes. It is more understanding which library to choose or which eco.

Reply on news.ycombinator.com