I don't think there is significant overlap between Python's ideal use cases and Haskells. For one, Haskell's advanced static type system lends itself nicely to formal verification and the handling of domain specific languages. Both domains are important in safety-critical software. It also has much better ways of dealing with concurrency (STM and linear types). On the other hand, Python's ecosystem seems to be centred around backend web development, data science, and machine learning.

They're both general-purpose high level languages suitable for application programming. The difference isn't so much in the sort of software you can write, but rather what you want your development/testing/debugging experience to be like.

I've never used Python, but I like Haskell for the kinds of problems where I'm trying to do something complicated and a little confusing, and I want the compiler to let me know if I've asked it to do something that doesn't make sense. That sort of thing can save a lot of time in the long run, and I usually feel good that the resulting software is reasonably robust. I expect a good Python programmer could write an equivalent program, it's just not the way I like to work.

Libraries are of course often a deciding factor, and so are performance requirements.

Most programming problems have multiple viable implementation approaches, and implementation language is not usually the gating factor on success.

It takes some esoteric innovative features to make a difference, but that will also cut both ways; it'll make it harder to hire for and scale, too.

If you want immutable data structures that simulate the behavior of mutable data structures look into Zippers. In this case, a list zipper.

For example, this problem of modifying the diagonal of a matrix can be solved quite easily:

  type Zipper a = ([a],[a])
  
  cursorOnDiagonal :: [[Int]] -> [Zipper Int]
  cursorOnDiagonal matrix = map (\(n,x) -> splitAt n x) (zip [0..(length matrix)-1] matrix) 

  flipToOneAtCursor :: [Zipper Int] -> [Zipper Int]
  flipToOneAtCursor = map (\(ys,x:xs) -> (ys,1:xs))   

  backToList :: [Zipper Int] -> [[Int]] 
  backToList = map (\(ys,xs) -> ys ++ xs)

If matrix == [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]], then:

  backToList . flipToOneAtCursor . cursorOnDiagonal $ matrix == [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]

I wonder if this can be linked in to Lamson

I'm curious about it, never heard about Lamson. What is it exactly?

It's Python mail server, that tries to be like Django for Mail. https://github.com/zedshaw/lamson/blob/master/README.md

The author's conception of philosophy seems to be heavily biased towards Western analytic philosophy whose pretension towards logically underpinning sciences and reliance on formal methods means that is more of a theoretical computer science or physics. Plenty of Continental philosophy: post-structuralism, deconstruction, post-colonialism, and non-Western philosophy (such as decolonial thought) speaks to and about daily life.

Maybe I'm just ignorant, but I don't see post-structuralism or deconstruction as having all that much to say about daily life. (Almost) nobody actually lives that way. That is, when you go out for a beer with your friends, you talk to them as if humans can actually communicate, and as if the message sent will be (approximately) the message received.

This is a fair point, in the that conventional definition of post-structuralism as representation being bound to an interpretative context can be difficult see in daily life. However, such a view's application in Foucault's work I see manifest in my life all the time. For example, the concept of governmentality explains how we come to internalize the mandates of the state or capitalist power structure to say obey traffic laws (even when a cop is not there to observe and violating the law would not lead to harm). I should augment my list to say critical theory and Marxism as well. Such schools could explain a great deal about increasing income inequality, patent law, the insufficiency of 'nation' as a unit of analysis in a globalized economy...

I go out for a beer with my friends and talk to them about post-structuralism. ;)

Sure. But you probably don't deconstruct what they say during the conversation (except for example or for entertainment).

That's true. But that doesn't necessarily mean that it doesn't have an _impact_ on daily life. In other words, descontruction, specifically, is an analysis technique. The outcome of doing said analysis is separate from doing the analysis.

I thought that continental philosophy was having the same if not a harder time staying relevant?

It depends who you ask. Anglo-American philosophy departments tend to stay pretty far away from it, but it has a decent-sized popular audience--and literary studies, art criticism, and related disciplines often draw pretty heavily from it.

This is actually perfect for a library on algebraic structures I've been trying to make in Haskell. For example, how does one distinguish between elements in the Dihedral group of order 10 vs. Dihedral group on order 16 when obstensibly, they have the same representation. For now, I think Haskell programmers use type-level arithmetic libraries, but this is a much better solution.

Haskell is actively moving in the direction of adding dependent types too. I believe phase 1[1] of the plan[2] is slated for GHC 8.0 (the upcoming release), and I'm sure the rest of it will follow soon.

It's pretty exciting!

[1]: https://ghc.haskell.org/trac/ghc/wiki/DependentHaskell/Phase...

[2]: https://ghc.haskell.org/trac/ghc/wiki/DependentHaskell

Abstract Algebra by Benedict Gross from the Harvard Extension School.

this looks like [+] an excellent course, if only b/c it uses a text by Artin.

[+] http://wayback.archive-it.org/3671/20150529001651/https://ww...