Specifically, what does "simplicity of go" mean to you
2,777 karma · joined February 27, 2009
Contact me at mccracken.joel@gmail.com
If your reply to me seems unnecessarily combative, pedantic, or uncharitable, I will probably not reply. Its not worth talking with someone who appears to be intentionally misconstruing my words. Ain't nobody got time for that.
Specifically, what does "simplicity of go" mean to you
It made me a far far better engineer when I was first starting out.
There are lectures online for the book if you want to break up the tedium of just reading it.
I love org mode, but i think its best used by individuals. Now maybe if someone decided to standardize it, things would be different, but as it stands, don't use it on teams.
However, for your own, personal stuff, i think its great. For example I use org-roam to manage my knowledge base. This is an inherently personal pursuit so I'm not worried about using it for this purpose.
https://github.com/microsoft/vscode/graphs/contributors
How can you possible separate vscode "winning because of javascript" and "it has development budget X times the budget of Emacs"
I actually came into the haskell community expecting MORE of such behavior, becuase I think common wisdom is that Haskell is full of gatekeeprs. I've been quite surprised by how little of it there actually are.
I'm not sure I totally grok your point re: golang. Just go read Rob pike's statement. That doesn't mean much about golang per se; he may have been attempting to make something suitable primarily for beginners, and hit upon some kind of impossibly powerful design (i'm thinking like scheme or something). But I hear about how bad golang code has to be, and well it makes me very sad.
Of course, golang does solve actual very real problems, and failing to acknowledge this is holding back the industry 100%. It also meets people where they are, not where the language author is, which is of course something we really need to come to terms with as a group of people who want to push the industry forward.
I don't know any haskellers who I would think say or think the things you say. Most of them realize that they're into a niche thing. I think most of them want the good things of haskell to be shared to the larger community, but we just don't know how to get there from here.
Well, I take that back. There is one person I know of who is what I would consider gatekeeper-y, and I really generally disagree with him on almost everything, except I too like Haskell.
But this is one person out of the many many haskellers I know.
Its tricky because these are patterns that are familiar in Haskell but are not really taught in other settings.
Additionally, to really learn these, you need to experiment with them. Use them. etc. That's pretty hard to do if the learning resources are mostly in haskell and you don't really understand it.
Alternatively, this might help: https://github.com/MostlyAdequate/mostly-adequate-guide
Also alternatively, what I would do is just go slowly through the fp-ts code. Look at it a piece at a time and slowly grow your understanding.
This may also help https://www.amazon.com/Domain-Modeling-Made-Functional-Domai...
github.com/joelmccracken/reddup
https://haskellbook.com/ is how I got good at Haskell. If you can't get a copy, there are other ways to get good at it though! Just not necessarily any all-in-one resources.
I'm always willing to help folks learn Haskell tho, so if you have any q's get my email from my bio.
To me, there are far more jobs out there than I need. You only need one job at a time. So I like to keep my mainstream programming skills reasonably sharp, but focus most of my time on expanding my mind.
That "job market" skill doesn't really matter that much. Python or JavaScript is fine. I have done a lot more JavaScript than Python over the years, and prefer JS but its not that huge of a distinction.
Early in my career, one of the things that really mystified me was how easy it was fro complexity to get out of control. I've worked on several code bases where nobody really understood how they worked. The abstractions were all very fuzzy, and almost any explanation for how something worked needed to be verified by myself before I could trust it. This seems to be the default state, and even the projects that start with the best of intentions, people with enough skill, refactoring discipline, etc, still seem to end up that way. So, I've been on a quest for figuring out how why this is, and how to mitigate it.
What totally surprised me was that Haskell was the answer I was looking for. Pure functional programming keeps you honest. People don't generally realize how problematic side effects are; of course, they are necessary, but having side effects strewn throughout your code base makes it very hard to reason about. The problem is that these are so complex that its very hard to accurately categorize them, say placing them behind a function name.
Many languages have kinda sorta maybe started to understand this and try to restrict memory mutability, which is certainly important, but for me working in web apps I have seen far more "stateful" problems resultant from rampant database access. Save a record here, query a table there, etc etc. Side effects add a ton of complexity.
So, if you want to become a better programmer, and perhaps figure out why stuff gets to be so hard for no good reason, learn Haskell. Send me an email if you wanna chat more/hear some advice on getting started.
I don't know if Haskell will long term be the thing that brings controlled side effects to the larger ecosystem; there are numerous other attempts in the works. Monads for side effects are a goofy hack, however they work fine and are totally acceptable for use etc.
But I can say that I am 100% convinced that once this truth is more widely appreciated, it will cause a massive change. We're going to see an impact on order of the impact automatic memory management had on the programming world.
The notion of using pure functions as much as possible and keeping your side efects restricted to as small a surface area as possible is certainly applicable in Python. The thing is, as a programmer you don't get to trust that things are the way they seem without chekcing yourself, so you gotta read the code. But still, learning Haskell will make you a far better programmer in your day job.
Oh, and another note: lots of haskell programmers go crazy with abstract stuff. Just don't do that. KISS applies to the haskell world as much as it does everywhere else. If you do, your programs will become SO MUCH EASIER TO WRITE AND MAINTAIN.
But this all depends upon the goal of being a better programmer. Haskell will also expand your brain in a delightful way, but so will Racket, Prolog, etc. So YMMV.
I tend to vastly prefer a small, beautiful, principled, "growable" language over one that has many builtin forms. e.g. Scheme. Because, as I said, each of these features just makes it harder for other implementations.
FWIW I also don't think it made sense for JS to get a pipeline operator; only reaosn I like those is when a language supports user-defined operators. But, anyway.
http://www.jerf.org/iri/post/2958
https://philipnilsson.github.io/Badness10k/escaping-hell-wit...
The first one I think cuts through all of the crap surrounding them. They're just a design pattern. And the second one helps motivate them, showing the many contexts where the design pattern many apply.
fmap manipulate $ filter passes_filters producer_stream
And GHC has list fusion rules in this case (not sure if they exactly apply for list comprehensions; they probably do, but i'm not certain of that.)so IIRC the xyntax in haskell syntax your example would be smth like:
[ manipulate x | passes_filters x, x <- producer_stream ]
which is transformed to: do
x <- producer_stream
guard (passes_filters x)
manipulate x
Which I believe does not have the same run-time performance as my fmap/filter example; even if it does, I'm just saying I don't see it often, and its not idiomatic.Its different in python though because, well, python is more cursed.
But I think GP comment summarized it pretty well, it shows how they all relate to each other in a concise way. If its not enough of an explanation, ok, look for another.
Of course, there are lots of libraries that only have type signatures as documentation. I think most people think that's less than optimal, but the haskell community is much smaller than many others. So what you'll want to do is look for a blog post or something that explains it in more detail.
Many still hold it up as a model PL in various ways. I'm always promoting it myself ;)
I actually just recently saw it in production code for the first time and was like "whaaaat is that?" It had been so long since I saw one that I didn't recognize it at first.
The thing is, usually in real haskell code you aren't going to be using something that is roughly like set builder notation. Well at least, I haven't seen many scenarios where its needed. You're pulling data from someplace, manipulating it, etc, and then sending it somewhere else.
That's not to say that I'm absolutely correct on this or whatever. But to me, overall I think Haskell syntax is far too complex and has too many special cases, and given list comprehensions are exactly equivalent to doing the same thing via the list monad, I'd prefer they be gone.
I fear that someday we'll collectively need to replace GHC, and each and every weird edge case just means that its that much more of a giant task when that day comes.