Hacker News new | past | comments | ask | show | jobs | submit login

Modern programming is more than just the tool chain and package management. To me modern programming is more the wider adoption of concepts borrowed from languages like Haskell: like pattern matching and safer null checks (like Maybe or Option types). It also includes easy to use coroutines or a good concurrency story. Programming with new languages comes with more compile time checking and linting, less chances to make simple stupid typo-like errors that take hours to debug. The formatting and package management are all part of this of course.

I don't really hear people call vim or emacs old fashioned too much anymore. There are a lot of new vim and neovim and spacemacs users out there.

The social aspects of coding are very nice too. It's so great to be able to search GitHub for code to see how other people solved a similar problem to one I might be having.




>To me modern programming is more the wider adoption of concepts borrowed from languages like Haskell: like pattern matching and safer null checks (like Maybe or Option types). It also includes easy to use coroutines or a good concurrency story. Programming with new languages comes with more compile time checking and linting, less chances to make simple stupid typo-like errors that take hours to debug.

How old are these concepts? When I read this, it reads more like, "things I was unfamiliar with before, but I've heard of recently".


>How old are these concepts? When I read this, it reads more like, "things I was unfamiliar with before, but I've heard of recently".

Well, the age of a concept doesn't matter much.

What makes it old or modern is not the history of its invention or early years, but when it's popularized.


One thing that came up often in my PL theory classes: "cutting edge" features of popular programming languages lag cutting edge features of research languages by about 30 years.

The interesting consequence is: if you want to look for The Next Big Thing in programming languages, just go back 20 years!


Sometimes it takes a long time for good ideas to percolate from academia/research to the day-to-day practice of the craft.


> Programming with new languages comes with more compile time checking and linting, less chances to make simple stupid typo-like errors that take hours to debug.

Most of the "old languages" did not have this problem. This was a product of the 90s when people built a bunch of stuff really fast without stopping to think about whether what they were building was really a good idea.

So, it's a couple of decades later, but that part of the 90s spirit is still in full force today, but there are many many more programmers. The logical conclusion is that the garbage dump being built today is way worse than the garbage dump built in the past, and that should scare you if you think typo debugging was bad.


The microcomputer kinda reset the clock on software development, as there was little co-mingling of mainframe people and microcomp people.

And i can't help feel we had a similar reset with the iPhone intro, again because of a split between desktop people and mobile people.


These kids can't see the forest for the trees.

All the software is getting slower and more incomprehensible, and they think it's getting better.

P.S: Voting on HN does nothing to change anyone's mind. If you don't reply, you're basically just saying "nuh uh!".


Yeah, the fact that you are getting downvoted is proof that the average HN voter does not understand software.


If I understand your first sentence, I think it says there are "old languages" that are relatively devoid of footguns. If so, which languages?


I believe the standard example is Modula 2. Somewhat newer, but Ada is pretty great.


Just about any old language, including C post-ANSI. The main relatively-heavily-used offenders are Lisp and shell scripts of various kinds. (And I think "oops, you made a typo, you don't find out until you try to run it and happen to ht that branch of code, oops that did not happen for three months, who knows what other bombs are sitting there waiting" is one of the primary factors in Lisp not gaining wider adoption.)

I mean, C is less compile-time-checky than Pascal, but it is tremendously better than JavaScript in that regard. So is FORTRAN, etc, etc.


Using a Lisp compiler helps a bit.

  * (defun foo (alpha)
      (flet ((beta (bar)
               (+ alph bar)))
        (bet (beta 1 2))))
The Lisp compiler, here SBCL with its REPL, detects in this function above:

  * wrong number of arguments
  * undefined function
  * undefined variable
  * unused variable

Lisp compilers have only been made available as late as 1962, so that might explain why Lisp has no wider adoption...

  ; in: DEFUN FOO                                                                                                                                                 
  ;     (BETA 1 2)                                                                                                                                                
  ;                                                                                                                                                               
  ; caught WARNING:                                                                                                                                               
  ;   function called with two arguments, but wants exactly one                                                                                                   
  ;   See also:                                                                                                                                                   
  ;     The ANSI Standard, Section 3.2.2.3                                                                                                                        

  ;     (SB-INT:NAMED-LAMBDA FOO                                                                                                                                  
  ;         (ALPHA)                                                                                                                                               
  ;       (BLOCK FOO                                                                                                                                              
  ;         (FLET ((BETA #                                                                                                                                        
  ;                  #))                                                                                                                                          
  ;           (BET (BETA 1 2)))))                                                                                                                                 
  ;                                                                                                                                                               
  ; caught STYLE-WARNING:                                                                                                                                         
  ;   The variable ALPHA is defined but never used.                                                                                                               
  ; in: DEFUN FOO                                                                                                                                                 
  ;     (+ ALPH BAR)                                                                                                                                              
  ;                                                                                                                                                               
  ; caught WARNING:                                                                                                                                               
  ;   undefined variable: ALPH                                                                                                                                    

  ;     (BET (BETA 1 2))                                                                                                                                          
  ;                                                                                                                                                               
  ; caught STYLE-WARNING:                                                                                                                                         
  ;   undefined function: BET                                                                                                                                     
  ;                                                                                                                                                               
  ; compilation unit finished                                                                                                                                     
  ;   Undefined function:                                                                                                                                         
  ;     BET                                                                                                                                                       

  ;   Undefined variable:                                                                                                                                         
  ;     ALPH                                                                                                                                                      
  ;   caught 2 WARNING conditions                                                                                                                                 
  ;   caught 2 STYLE-WARNING conditions                                                                                                                           

  FOO


True, so true. The SBCL compiler is almost human; Once, it insulted me with something like: "You have assigned a value to an index out of bounds. Congratulations!!"

Keep on preaching, Rainer, and may the other programmers see the light.


Most of your comments would be vastly improved by omitting the reams of repl output.


if(foo = bar) { ... }




Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: