Programming paradigms that change how people think about coding (2014)

I find it interesting that the discussion on Dependent Types lists Idris and Coq as languages and discusses Formal Verification but mostly focuses on Idris and Scala with Shapeless... but to my knowledge, Coq has actually won out in 2019 for this, and Coq has even branded itself for this specifically[0].

[0] https://coq.inria.fr/ - Coq is a formal proof management system.

LaTex is the only system I know that comes close to this, but the language is pretty horrible to actually try and use (to be fair, LaTex has quite a bit of legacy it has to maintain).

Also:

1) The sorting example is O(n!) not because of limitations of the language, as the article suggests, but because the algorithm implemented is permutation sort, which is O(n!).

A typical sorting algorithm example in Prolog is merge sort which is as efficient in Prolog as merge sort can be. Here are a few sorting algorithms in Prolog, including merge sort and quick sort:

http://kti.ms.mff.cuni.cz/~bartak/prolog/sorting.html

2) The Sudoku example uses a Constraint Logic Programming library implemented in Prolog (from the looks of it, Gnu Prolog). CLP is a different paradigm than plain logic programming, where one programs by specifying constraints.

A Sudoku solver in actual Prolog can be found in "99 Prolog Problems":

https://www.ic.unicamp.br/~meidanis/courses/mc336/2009s2/pro...

The sudoku solver is number 97.

  This is the TXR Lisp interactive listener of TXR 212.
  Quit with :quit or Ctrl-D on empty line. Ctrl-X ? for cheatsheet.
  1> (mlet ((w 3)
            (x (+ z w))
            (z (* 2 w)))
       (list x z w))
  (9 6 3)

  2> (macroexpand '(mlet ((w 3)
            (x (+ z w))
            (z (* 2 w)))
       (list x z w)))
  (let (#:g0011 #:g0012
        #:g0013)
    (symacrolet ((w (force #:g0011))
                 (x (force #:g0012))
                 (z (force #:g0013)))
      (set #:g0011
        (delay 3))
      (set #:g0012
        (delay (+ z w)))
      (set #:g0013
        (delay (* 2 w)))
      (list x z w)))

  1> (mlet ((x y) (y z) (z x)))
  nil
  2> (mlet ((x y) (y z) (z x)) x)
  ** (expr-2:1) force: recursion forcing delayed form y (source location n/a)

Wolfram could have implemented his large standard library also for any other ecosystem. The magic of this library (which goes along with Wolfram's Lisp dialect but is considered as a unit) is that it is extremely high level, allowing rapid application development. But as with most libraries, it could have been developed for any language/idiom, such as a traditional object oriented python.

How about C90: pointer to array of 10 is not compatible with a pointer to array 20:

  int process_array(int (*pa)[20]);

  int main(void)
  {
    int array[10];
    process_array(&array);
    return 0;
  }

  array.c: In function ‘main’:
  array.c:6:17: warning: passing argument 1 of ‘process_array’ from incompatible pointer type [-Wincompatible-pointer-types]
    process_array(&array);
                 ^
  array.c:1:5: note: expected ‘int (*)[20]’ but argument is of type ‘int (*)[10]’
   int process_array(int (*pa)[20]);
       ^~~~~~~~~~~~~

I'd love to see a world where wolfrom pulls on datasets out in the wild much like a search engine scrapes web pages but is such a thing possible? It begins to sound like a SOAP/WSDL fever dream when you think about automatic knowledge integration.

Maybe something closer to the open source package managers? Wolfram datasets could specify interfaces and dependencies? At least that would allow for new and exciting datasets to gain adoption in the community.

https://news.ycombinator.com/newsguidelines.html