Be aware that as a small and very distributed community, the Haskell world has less power to eject bad actors than more centrally managed and resourced projects have (e.g., Golang and Rust have much more structural power to moderate). Awful and abusive people exist in the community, and it's best to just start blocking and ignoring folks who disrespect you.
The amazing thing about the Haskell community is that knowledge is very well distributed throughout the community these days. The culture, influenced by academia, strongly values writing and publishing ideas rather than sharing them orally or in the workplace. This means that if you're interested in learning, there are a ton of places and ways to do it.
If you're looking for good initial connections to folks who are respectful, well informed, and unlikely to expose you to some of the frustrating cabals in the community, I've got a few recommendations
1. Gabriel Gonzales (this is his blog, and he's @GabrielG439 on twitter)
2. Chris Martin of TypeClasses. I'd also list his partner in crime Julie Moronuki, but her social media interaction is reduced these days. These two focus on helping programmers get up to speed with haskell from a variety of starting points, and they care more about functional programming than haskell specifics.
3. Patrick Thompson of Github (@importantshock on Twitter). A fantastically skilled person who will link you to a network of amazing Haskell folks who do stuff in a positively next-generational way.
Two people who are adjacent to the Haskell community and incredibly interesting, but probably can't answer direct questions for you. Worth a follow.
1. Dr. Edwin Brady, creator of the Idris language. He's widely respected, humble, and has a beautiful vision for how humans and computers should interact to write programs.
2. Dr. Bodil Stokke (@bodil on twitter). Bodil is not so much a Haskell person these days, but she's got a phenomenal breadth of knowledge and always has interesting things to talk about in the FP space. Worth a follow if you're on that platform.
I suppose you can ask me for help too, but I'm certainly not as competent as these folks.
Shoutout if you're in the SF area, BayHac (https://wiki.haskell.org/BayHac2018), a yearly unconference/hackathon is incredibly fun, and also there are (roughly) bi-monthly Haskell meetups (https://www.meetup.com/Bay-Area-Haskell-Users-Group/) in SF which are great fun (disclaimer: I co-organise the meetups - find me @Nick_enGB).
Are you referring to people saying negative things about Learn You A Haskell?
Scala's community essentially began to adopt a thinly-coded code of conduct that said, "Don't be like Tony Morris he literally runs people out of the scala community" it got so bad. He continues to be unrepentant and uses his influence to fan a slow but very distressing conflict between the Cabal community and the Stack developer community.
As for LYAH, it's a decent book. It's got its problems (in some cases it does obnoxious and useless things like make fun of overweight people).
What's his (Tony Morris') point? Is he putting on a show or is that for real?
He blocked me when he read my prior comment.
And not that it excuses his behavior, but I also seem to recall Tony suffering from some very severe back injuries accompanied by chronic pain.
(Not to white knight a person I'm barely aware of but your description seems pretty one-sided based on what I've seen)
Not that I agree with this narrative, because AFAICT it wasn't true, but even if it were? Good. That's the power and mechanism open source working as intended. If you're a burden to the project, you're cast off. And Tony is an insufferable burden. The code is free, and owned by the group.
The fact that he expected "ownership" of a project set up with a leadership committee is a good example of the kind of silly behavior I'm talking about.
> And not that it excuses his behavior, but I also seem to recall Tony suffering from some very severe back injuries accompanied by chronic pain.
I was around for two public declarations of dramatic self harm. I'm told there are more. And I hope he finds a way to deal with these problems, they're serious and can be life threatening. I don't wish violence on him.
But I want him to stop making communities worse with his senseless negativity and hostile communications. If he has problems in his life that impair his ability to interact in this fashion, we should not enable his abusive behavior out of charity. That's actually disrespectful, and while it may benefit Tony in the short term, in the long term he finds himself forced out of communities that no longer can or will bear the weight of his presence.
> your description seems pretty one-sided based on what I've seen
It's certainly one sided: it's my side. I for one ran into him a lot. It seems like he took special delight in demanding I take his impromptu "quizzes" in Scala and he'd hound me ceaselessly until I did. His ultimate goal was to prove I was "not a functional programmer." He's been cut off by a lot of longtime members of the FP community for a reason.
Thanks for sharing your unfortunate experience, and I agree that health problems or things like that should not be an excuse to behave poorly. Take care.
This idea of a hostile takeover and such is a figment of Tony's imagination and a deliberate distraction equivalent to Trump's referring to the Mueller investigation as a witch hunt.
Most folks agree that Tony should be off the project. The problem of one overzealous person trying to get Tony to shut up is a separate and regrettable decision on his part. CoCs act to protect people from behavior like Tony's, not to be a cudgel. AFAIK, it's faced subsequent edits to improve that.
It's unfortunate that Tony's become so incapable of modulating his behavior in public that he forces these issues. It's doubly regrettable that folks associated with the same projects he has contributed to could not handle the unusual situation with more grace and poise.
Speaking of "frustrating cabals" just be prepared for a hefty infusion of socialist ideology into your stream with this follow. Might get a bit grating if that's not your politics, your family is currently fleeing Venezuela, you don't enjoy irony in the contrast with her interleaving pictures of her expensive toys and housekeeper-maintained upper-class London apartments paid for by her FinTech job, etc. (inb4 "there's no such thing as ethical consumption under capitalism").
: Unfortunately this is pretty common in PL Twitter and is a downside to the "influenced by academia" notion you bring up (https://theotherlifenow.com/occupations-and-their-ideologies...)
But anytime you make a list of "here are people who are helpful and won't demand much but courtesy in return" in the Haskell community folks like you pop up demanding I mention your favorite guy like he's relevant or necessary. Go write your own list if you want your gab.ai fp follow list.
I don't have a "gab.ai fp follow list" because I don't like mixing politics with programming precisely because it devolves into the kind of tribalism on display here.
I'm sorry you took offense to "these kinds of comments" but I don't see how you're entitled to put Tony Morris on blast for your experiences but I can't share my own (admittedly passive) experience with Bodil?
Perhaps follow your own claimed ethics and don't pollute this conversation with politics? It's not like my list wasn't quite diverse in the political spectrum.
I'm doing my best to avoid concrete assertions about your personality or preferences. But I can't help but notice that you're acting in a manner contrary to your stated preferences.
> Some people learn Haskell with the expectation that they will achieve some sort of programming enlightenment or nirvana. You will be disappointed if you bring these unrealistic expectations to the language.
While I have not achieved any sort of nirvana, I do believe that learning Haskell has "enlightened" me insofar as I now look at programming in a fundamentally different way. I put a much greater emphasis on writing many small functions, I use types wherever possible (and type hints too, since Python is my primary language), and I avoid side-effects when I can. All of these things I do because Haskell taught me just how powerful simplicity can be.
I also learned about different ways to conceptualize the relationships between data, and I learned about laziness (something I'd never heard of before then). Haskell has a lot to offer for people who come from an imperative background.
> Haskell is not an achievement to unlock or a trophy to be won because learning is a never-ending process and not a finish line.
While you can never "finish" learning, you can set milestones to mark your achievement. Comprehending some of Haskell's features (both the basics and the advanced ones) are perfectly acceptable milestones by which to track progress. I don't think that's a bad thing.
That said, overall the article is very good. I agree that newcomers should write small programs, get their hands dirty, and learn to really use the basic features of the language firsthand before moving on to more advanced things. (And especially I agree that new users should avoid typeclasses at first, or even at second.)
Perhaps I could have worded that better. Sorry for the confusion.
Yes, sorry, I think I didn't explain myself very well.
Prior to learning Haskell and embracing The Way, my code was fairly covered in side-effects. I was a relatively junior programmer at this point (many years of experience because I started young, but few years of real education). Side-effects were just, you know, a thing that happened because they were "the easy way".
After learning Haskell, I became much more conscious of side-effects. I realized that a lot of things I used to do could be done without side-effects, mostly by writing better functions and thinking more deliberately about how to eschew the side-effects.
That said, it's not like they're gone. It's just that I'm much more careful about them. I "avoid" them in that I do my best not to include them, but if there's a genuine use for them then that's fine. However, I have taken to naming my functions better to reflect their side-effecting nature, and I try to move the side-effecting functions to places that make more logical sense (instead of just wherever).
I think the truth is somewhere between "programming nirvana" and "no more null pointers and undefined functions".
Can I ask whether Haskell in particular led to this enlightenment, or if functional programming is the underlying concept responsible? I've been considering learning Julia for fun and am wondering if it would impart some of the same benefits.
That said, my first success with functional programming was actually with Racket. Racket is great for learning (in my opinion), but the "lessons" Racket had to offer weren't really solidified for me until I moved to Haskell. At that point, things really started to click.
That could be due to any number of things, though. However, certain concepts (e.g., laziness, typeclasses) are more Haskell-specific (or at least are not common among all functional languages).
It definitely helped later when I started working on a language myself, and now needed to write a parser and do a lot of transformations using uniplate.
My biggest piece of advice for beginners trying to do anything more complicated that requires dependencies is to use stack and set up a skeleton project.
Set up your stack.yml file with the latest nightly (hack on nightlies, release on LTS) and then visit stackage to see docs _completely in sync with the versions you're using_. You should just be able to add dependencies you need to package.yml.
That gets you a fairly stable environment where things will actually do what you expect, which eliminates a big source of confusion and frustration.
For newbs stack is fine. But I genuinely question any serious code base that needs stack. Genuine cabal hell hasn’t existed since around 2010. And the mini purgatory that some people call hell is impossivle with cabal new build.
My perspective is perhaps biased, but I also am comaintainer of widely used libraries used literally everywhere plus I’ve done commercial and recreation and research flavors haskell dev for over a decade, currently at a fortune 10ish sized company.
Though zooming out: these days I tell learners they should try everything out, and revisit various tools as their mastery grows.
For industrial / large prjects that want pinned deps, I’ve seen folks happy with the mafia build tool or even going full nix for end to end os level reproducible build and config.
My main issue with workflows like those centered around stack is that I’ve seen a lot of folks just not think about library versions and deps as part of their library/application foot print. And this has various consequences in how they engineer and upgrade their own libraries and applications.
Haskell aside, I think this is a fantastic point regardless of whatever it is you're learning. There's always so much more to learn and having this mindset makes it a lot easier to do so.
"A classic is something everybody wants to have read, but no one wants to read." --Mark Twain
Even if the ecosystem changed and some great libraries appeared since I last tried, the language itself is a bad match for those domains. Lazyness is great everywhere, except when it works against you, and the garbage collector will assure you notice it.
1 - On my case, userspace drivers. I'm still open to userspace filesystems (I have on on my TODO list, if I ever get there), but device controlling implies on some harder real time requirements.
> Haskell is a garbage collected language, so Haskell is more appropriate for the scripting / logic layer of a game but not suitable manipulating a large object graph or for implementing a high-performance game engine due to the risk of introducing perceptible pauses due to GC pauses. Also, for simple games you can realistically use Haskell for the entire stack.
None of that is a showstopper. But I'd rather use a language that doesn't suffer from fundamental drawbacks on the domain I will work.
That said, Haskell is very promising for AI. If I ever get to that game again, I'm writing the main loop in Rust with an asynchronous AI in Haskell.
Action games are thus fundamentally hard-real-time systems.
One technique used for writing games to run on GC'd runtimes is to avoid allocations entirely in the game loop. With a lot of work, you can preallocate everything you're going to need and just modify it as you run.
This technique is not a good match for Haskell's primary design principle of avoiding mutable state.
If your game has real time dynamics, it's not worth it. If it's some turn-based one without animation, it's not a problem.