There's a classic article named On the Criteria To Be Used in Decomposing Systems into Modules that I just read for the first time.  It makes perfect sense to me, and is probably one of those articles that OOP was based on.  Its conclusion:We have tried to demonstrate by these examples that   it is almost always incorrect to begin the decomposition   of a system into modules on the basis of a flowchart.   ... Each module is then designed to hide   such a decision from the othersIn my uneducated and inexperienced opinion, functional programming takes the exact opposite advice of this article.  My understanding is functional programming makes data flow idiomatic.  Data gets passed from function to function, each function being intimately aware of the data and changing it along the way.  And I think I've seen a Rich Hickey talk where he talks about how data hiding is overrated or unnecessary or something, but I can't remember for sure.  First I want to know if my assessment is correct.  Does the FP paradigm and this article philosophically disagree? Assuming they disagree, how does FP compensate for its lack of data hiding?  Perhaps they sacrifice data hiding but gain X, Y and Z.  I'd like to know the reasoning for why X, Y and Z are considered more beneficial than data hiding.  Or, assuming they disagree, perhaps FP feels that data hiding is bad.  If so, why does it think data hiding is bad?Assuming they agree, I'd like to know what FPs implementation of data hiding is.  It's obvious to see this in OOP.  You can have a private field that nobody outside the class can access.  There's no obvious analogy of this to me in FP.I feel there are other questions I should be asking but I don't know I should be asking.  Feel free to answer those, too.  UpdateI found this Neal Ford talk that has a very relevant slide in it.  I'll embed the screenshot here:
Does functional programming ignore the benefits gained from the On the Criteria To Be Used in Decomposing Systems into Modules (data hiding)?
design;object oriented;functional programming;object oriented design
The article you mention is about modularity in general, and it would apply equally to structured, functional, and object-oriented programs.  I have heard of that article before from someone who was a big OOP guy, but I read it as an article about programming in general, not something OOP specific.  There is a famous article about functional programming, Why Functional Programming Matters, and the first sentence of the conclusion states In this paper, weve argued that modularity is the key to successful programming.  So the answer to (1) is no.  Well designed functions don't assume more about their data than they need to, so the part about intimately aware of the data is wrong.  (Or at least as wrong as it would be of OOP.  You can't program strictly at a high level of abstraction and ignore all details forever in any paradigm.  In the end, some part of the program does actually need to know about the specific details of the data.)Data hiding is an OOP specific term, and it isn't exactly the same as the information hiding discussed in the article.  Information hiding in the article is about design decisions that were hard to make or are likely to change.  Not every design decision about a data format is hard or likely to change, and not every decision that is hard or likely to change is about a data format.  Personally, I can't see why OO programmers want everything to be an object.  Sometimes, a simple data structure is all you need.  Edit:I found a relevant quote from an interview with Rich Hickey.Fogus: Following that ideasome people are surprised by the fact that Clojure does not engage in data-hiding encapsulation on its types. Why did you decide to forgo data-hiding?Hickey: Lets be clear that Clojure strongly emphasizes programming to abstractions. At some point though, someone is going to need to have access to the data. And if you have a notion of private, you need corresponding notions of privilege and trust. And that adds a whole ton of complexity and little value, creates rigidity in a system, and often forces things to live in places they shouldnt. This is in addition to the other losing that occurs when simple information is put into classes. To the extent the data is immutable, there is little harm that can come of providing access, other than that someone could come to depend upon something that might change. Well, okay, people do that all the time in real life, and when things change, they adapt. And if they are rational, they know when they make a decision based upon something that can change that they might in the future need to adapt. So, its a risk management decision, one I think programmers should be free to make.  If people dont have the sensibilities to desire to program to abstractions and to be wary of marrying implementation details, then they are never going to be good programmers.