Difference between revisions of "Talk:Open research problems"

From HaskellWiki
Jump to: navigation, search
m (Extra paragraph added; spelling corrected;)
m
 
(2 intermediate revisions by the same user not shown)
Line 1: Line 1:
 
== Denotative languages and the I/O problem ==
 
== Denotative languages and the I/O problem ==
   
  +
<div style="border-left:1px solid lightgray; padding: 1em" alt="blockquote">
  +
My view is that the next logical step for programming is to split into two non-overlapping programming domains:
  +
  +
* runtime building for …
  +
* … mathematical programming languages
  +
  +
<tt>[https://www.haskellforall.com/2021/04/the-end-of-history-for-programming.html Gabriella Gonzalez].</tt>
  +
</div>
   
 
Let's assume:
 
Let's assume:
Line 30: Line 38:
 
They [monadic types] are especially useful for structuring large systems. In fact, there's a danger of programming in this style too much (I know I do), and almost forgetting about the 'pure' style of Haskell.
 
They [monadic types] are especially useful for structuring large systems. In fact, there's a danger of programming in this style too much (I know I do), and almost forgetting about the 'pure' style of Haskell.
   
<tt>Noel Winstanley, 1999.</tt>
+
<tt>[[Monad tutorials timeline|Noel Winstanley]].</tt>
 
</div>
 
</div>
   
 
Instead of [http://conal.net/blog/posts/can-functional-programming-be-liberated-from-the-von-neumann-paradigm looking at the whole system in a consistently denotational style (with simple & precise semantics)] by using <i>DL</i> alone, most users would be working on the implementation using <i>IL</i> - being denotative makes for nice libraries, but getting the job done means being imperative. Is this an improvement over the current situation in Haskell? No - instead of having the denotative/imperative division in Haskell by way of types, users would be contending with that division <i>at the language level</i> in the forms of differing syntax and semantics, annoying foreign calls, and so forth.
 
Instead of [http://conal.net/blog/posts/can-functional-programming-be-liberated-from-the-von-neumann-paradigm looking at the whole system in a consistently denotational style (with simple & precise semantics)] by using <i>DL</i> alone, most users would be working on the implementation using <i>IL</i> - being denotative makes for nice libraries, but getting the job done means being imperative. Is this an improvement over the current situation in Haskell? No - instead of having the denotative/imperative division in Haskell by way of types, users would be contending with that division <i>at the language level</i> in the forms of differing syntax and semantics, annoying foreign calls, and so forth.
   
The advent of Haskell's FFI is a further aggravation - it allows countless more effect-centric operations
+
The advent of Haskell's FFI is an additional aggravation - it allows countless more effect-centric operations to be accessed. Moving <b>all</b> of them into a <i>finite</i> implementation isn't just impractical - it's impossible.
to be accessed. Moving <b>all</b> of them into a <i>finite</i> implementation isn't just impractical - it's impossible.
 
   
 
But if you still think being denotative is worth all that bother (or you just want to prove me wrong :-) [https://www.ioccc.org/2019/lynn/hint.html this] could be a useful place to start:
 
But if you still think being denotative is worth all that bother (or you just want to prove me wrong :-) [https://www.ioccc.org/2019/lynn/hint.html this] could be a useful place to start:

Latest revision as of 21:49, 24 November 2021

Denotative languages and the I/O problem

My view is that the next logical step for programming is to split into two non-overlapping programming domains:

  • runtime building for …
  • … mathematical programming languages

Gabriella Gonzalez.

Let's assume:

  • a denotative language exists - here, it's called DL.
  • the implementation of DL is written in an imperative language - let's call that IL.

Let's also assume:

  • DL is initially successfull.
  • solid-state Turing machines remain in use, so IL is still needed.

As time goes on, technology advances which means an ever-expanding list of hardware to cater for. Unfortunately, the computing architecture remains mired in state and effects - supporting the new hardware usually means a visit to IL to add the extra subroutines/procedures (or modify existing ones) in the implementation.

DL will still attract some interest:

  • Parts of the logic required to support hardware can be more usefully written as DL definitions, to be called by the implementation where needed - there's no problem with imperative code calling denotative code.
  • periodic refactoring of the implementation reveals suitable candidates for replacement with calls to DL expressions.
  • DL is occasionally extended to cater for new patterns of use - mostly in the form of new abstractions and their supporting libraries, or (more rarely) the language itself and therefore its implementation in IL.

...in any case, DL remains denotative - if you want a computer to do something new to its surroundings, that usually means using IL to modify the implementation of DL.

So the question is this: which language will programmers use more often, out of habit - DL or IL?

Here's a clue:

They [monadic types] are especially useful for structuring large systems. In fact, there's a danger of programming in this style too much (I know I do), and almost forgetting about the 'pure' style of Haskell.

Noel Winstanley.

Instead of looking at the whole system in a consistently denotational style (with simple & precise semantics) by using DL alone, most users would be working on the implementation using IL - being denotative makes for nice libraries, but getting the job done means being imperative. Is this an improvement over the current situation in Haskell? No - instead of having the denotative/imperative division in Haskell by way of types, users would be contending with that division at the language level in the forms of differing syntax and semantics, annoying foreign calls, and so forth.

The advent of Haskell's FFI is an additional aggravation - it allows countless more effect-centric operations to be accessed. Moving all of them into a finite implementation isn't just impractical - it's impossible.

But if you still think being denotative is worth all that bother (or you just want to prove me wrong :-) this could be a useful place to start:

  • OneHundredPercentPure: Gone is the catch-all lawless IO monad. And no trace of those scary unsafeThisAndThat functions. All functions must be pure.

Atravers Fri Oct 22 06:36:41 UTC 2021