Today, I'm proud to announce a (free and open-source) project that I've been working on for many years:
NeoHaskell, a dialect of Haskell that prioritizes newcomer-friendliness and productivity.
I embarked on the NeoHaskell project fueled by a diverse array of motivations. I see Haskell as a supremely potent language, leading the frontier of software development due to its inventive and meticulously crafted nature. However, its potential seems overshadowed by intricate details and a community primarily focused on resolving theoretical academic and mathematical challenges, often overlooking pragmatic solutions, which can be overwhelming for newcomers. Based on my experience with incorporating Haskell into production for two years and the subsequent transition to TypeScript due to escalating complexity, after innumerable conversations with my colleagues at The Agile Monkeys, a critical need for a language that could refine software development while preserving the groundbreaking aspects of Haskell was recognized. This realization, coupled with the challenges encountered in the software development sector, inspired the creation of NeoHaskell. Through this initiative, I aspire to develop an optimal programming language and ecosystem that eradicates accidental complexity, either in mental form, or in code form.
This is a language for those who have just too many things in their head and they want to release their ideas, but don't have the time to commit daily to maintain the required context of their projects in their heads. For those who want to play and have fun while producing awesome software, regardless of their experience, background, or interests. And for those teams that, inevitably, are high-rotational (either internally in the company, or externally) but want to be productive and happy while performing their craft.
A language? A dialect? What do you mean?
Depending on who you ask, a programming language can be different things. If you ask the Haskell community, many will tell you that the language is the Haskell specification, and that what currently is being used is not Haskell itself, but an extension of Haskell that is supported by the GHC compiler. Similar to the C language, a programming language would be a specification.
Other people might tell you that a programming language is the result of the supported features of its compiler, like Rust, which keeps evolving with time.
I personally think that a programming language is the result of the agreement of its community on tools, libraries, patterns and practices. I hear folks saying "he didn't learn Python, he is programming in Java in Python", which is the affirmation of this.
NeoHaskell exploits this philosophy to establish a parallel universe in the Haskell ecosystem, piggybacking the extremely good tooling and libraries that are already there, and were there for a long time. It establishes completely different patterns, practices, naming, and even approaches to code that would be considered heretic in Haskell.
The solution is not having more hands implementing more features, the solution is to stop. And prioritize as if this was a product.
This is not a priority for the Haskell community, and that's the point:
NeoHaskell is not Haskell, it's a parallel universe built on top of it.
What's the goal?
NeoHaskell’s core mission is to provide a seamless, productive ecosystem for joyful software development. It’s designed to guide developers toward faster, more reliable releases, through a concentrated effort to alleviate cognitive load, by removing unnecessary complexity and decision making.
We welcome developers from diverse backgrounds, including backend and frontend development, data analysis, mobile development, game development, and whatever you can image. While simplification of the development process is a priority, NeoHaskell also emphasizes the importance of improving developer satisfaction by incorporating structured architectures to reduce decision making even more.
NeoHaskell's vision is to render the development process more user-friendly and enjoyable, enabling users to realize their ideas effortlessly and efficiently. It wants to transform the development experience, making it feel more like “play” rather than “work.”
Why not just documenting Haskell?
If you think in a programming language as the subconscious agreement of its community, the key part is the way of working and approaching programming as a group. In the same way that the Java community is used to work in a way by defining factories, beans, etc… The Haskell community is used to work in their own way too. It is not wrong, or incorrect, they have their own goals.
The issue is, that documenting technology is easy, changing the minds of an entire community is not.
I'm a single person trying to fix the world. I have limited time and energy, and I don't want to be changing the views of anyone. I'm doing this in my free time, time that I dedicate to be more happy. Convincing people doesn't make me happy.
I'm building a wagon that is open for everyone who wants to hop on and support it, but I don't want to deal with people that don't.
I want to establish a new concept so it is easier for newcomers to find resources and get up and running in the most effective way possible, all while feeling unstoppable because they're using a tool that they love.
In response to any skepticism from the Haskell community, I understand the seen sufficiency of Haskell in its present state given their context and experience. Most of them are very smart people, and great professionals, and they are completely right to think in that way.
However, when considering individuals with diverse approaches to software development, like those viewing programming languages as tools, or those valuing release speed over perfection, including early-career developers with abundant creative ideas, the priorities noticeably shift.
NeoHaskell is focused on enabling swift and assured releases, valuing user-friendliness and practicality over aspects like precision, code accuracy, and complex type-level code for the sake of perfection. The project recognizes that developers have varied needs, and it commits to catering to those prioritizing efficiency and feasibility in bringing their visions to life.
What are you trying to solve exactly?
There are too many entry points to a simple task as running your code, such as plain GHC, Cabal, Stack, Nix, etc., each presenting its learning curve and absence of a recognized superior option. The environment is further compounded by multiple language extensions and different frameworks handling side effects. These, combined with the daunting mathematical concepts in the language, often discourage newcomers.
Not even mentioning even more niche workflows like mobile apps, web apps, and even game development, that are there, but are hidden deep down under layers of accidental complexity.
NeoHaskell counters these challenges by introducing a unified CLI tool that simplifies everything, from installing the required compiler to managing packages and running tests. It streamlines all the different workflows through official templates, so one can get started right away with the task that they want to do.
We aim to support newcomers by providing analogies to other languages and featuring these in the documentation to facilitate comprehensive learning, while renaming or discarding terms that would be unnecessarily complex for newcomers.
How are you trying to solve it?
NeoHaskell’s development is centered around the principle of catering to its community, the NeoHaskell community, avoiding the trap of chasing unrealistic perfection and ending up with an unused product after years of development.
The main goal is to create many different pieces:
- A remarkable standard library
- An integrated CLI tool with precise error messages
- Templates with planned architectures
- Documentation with a set of recipes
- Mobile app packaging
- Python interoperability
- And many more
These objectives, though ambitious, are attainable by delivering small increments and focusing on fostering one essential element: developer joy.
Rather than promoting the creation of new architectures and the innovative use of advanced features, NeoHaskell favors well-established patterns in the software industry and embraces functional programming where appropriate, allowing for imperative code where it’s more suitable. Comprehensive documentation, a supportive Discord community, and a philosophy of "if it takes more than 15 mins to figure out, it is a bug" are the key points to ensure the success and happiness of its users.
One of the key ideas of NeoHaskell is to reuse as much technology as possible, while staying in the realm of NeoHaskell. This approach opens up many paths, and leads you very far. Our goal is to be happy while coding what makes our project different, not all the bullshit that just gets in the way. If your goal is to make a todo-list mobile application in the most joyful way, using NeoHaskell, you shouldn't think at all in how the rendering of the view is actually implemented. Even if the mobile app is a React Native renderer of HyperView XML views that are retrieved from a 100% NeoHaskell backend, as shown in this tweet:
When you approach development like this, by doing concessions, instead of closing doors, you open up the door for innovation and improvement, while maintaining a healthy and productive ecosystem. The other way around, you end up with a wasteland filled of gardeners ensuring that someday, the plants will grow exactly in the perfect way that they want.
How does it piggy-back the Haskell ecosystem?
NeoHaskell preserves 100% compatibility with Haskell, seamlessly integrating existing packages and tools designed for Haskell. However, its goal is not to be backward compatible. It will refine several elements from the Haskell standard library, with functions being renamed, certain operators being concealed and new ones introduced, and type classes being restructured to ensure their practical applicability, if they are applicable.
NeoHaskell will actively utilize compiler plugins to modify the compiler’s behavior to align more with newcomer friendly messages and features. It will maximize the potential of existing libraries, sometimes through encapsulation or re-exportation, as well as the usage of all the plethora of great CLI tooling that exists for Haskell.
How will be the design and priorization process?
I believe that in order for a product to be successful, the design process must be centralized in a single person. This person must listen to the users, the other designers, and in general must have an open mind to always cherry-pick all possible ideas in order to improve the product. I don't believe that a product should be guided by democracy, and neither it should implement all suggestions by every user. In other words, I'll be the one in charge of generating and listening to discussions, and prioritizing the features of the project.
I understand that this comes with some risk, but at the same time I believe that all programming tools like Python and Ruby that are very loved by their communities are like that because of the BDFL model.
NeoHaskell's development will be open and transparent, marked by continuous sharing of progress and regular updates. My biggest priority is to maintain the community informed and aware of my vision, not getting into some kind of spiritual retreat to code while everyone thinks that the project has stalled and I have disappeared.
Anyone interested can contribute by participating in discussions on Discord and GitHub. Contributions go beyond code, the most important part is the design process, and that can only be achieved through communication between the members of the community.
I want to contribute, where is the code?
If you've read "the project that I've been working on for many years" as "the project that I've been coding for many years", I'm sorry to disappoint you, that is not the case.
I'm glad that it isn't, because that would have been a complete mistake. Design is a thinking process, is a communication process that goes back and forth. It is about talking to people, listening to every conversation with an open mind. Getting into tasks that you don't like and doing them for the sake of understanding what's going on, what are the users doing, and what is this thing that could improve their lives.
I didn't code NeoHaskell, instead I wrote TypeScript, both for backend, frontend, CLI tools, infra-as-code, and many more things. I worked with enterprise clients whose teams are so big and the team member rotation is so high, that every little code pattern had to be stitched in the exact same way so there were no surprises when team members rotated. I coded plain Java, as well as Python, in the most boring and bland way possible. All of that, taking notes and gathering insights for NeoHaskell. That is the real work. Getting all these puzzle pieces that are spinning in a tornado around you, picking them up, while attempting to stay on the ground and assembling the puzzle.
There's this thing that people call "Haskell curse", which is the feeling of disgust for using other, inferior, technologies that aren't Haskell.
NeoHaskell lifts the curse. Every interaction with technology and users from other ecosystems becomes a blessing, and an opportunity to understand what makes us happy as software craftspeople. Every frustration becomes a leverage point to create the most awesome language, ecosystem, and community ever in the world. So, check out the website, join the Discord, and hop into the project's GitHub, this is not possible without you (literally).
Afterword
Writing this post was not easy at all. I'm very happy that this project finally sees the light, because I truly believe since the day I discovered Haskell in that old dusty book in my faculty's library, that it has the power to be the leading language in software industry. You cannot imagine how many different attempts that I've tried, how many prototypes I actually wrote, and how many conversations I had with developers who thought that Haskell is just hipster bullshit that is not useful at all.
If you've read this far, let me thank you from the deepest part of my heart, even if you don't believe in this project, or you're not interested, and if you are, have this huge virtual hug and let's chat! I'm eager to talk with people that are interested in this idea.
NeoHaskell may evolve as a specialized community or may blossom into something more extensive and mainstream.
My hopes are humble: for it to serve as an invaluable resource enabling the community to experience continual satisfaction, and for it to encourage the Haskell community to emphasize practicality and inclusivity.
Thank you, really,
NickSeagull
Top comments (23)
Great post my friend, I see myself as one wannabe Haskell developer who always give up because all that complexity that you mention. Fortunately, I found refuge in Ruby, but the intention to go deeper with Haskell is always behind me 🤣 like a shadow.
Glad that you've liked it, I hope one day NeoHaskell will be so smooth that you can replace Ruby with it :)
I support your goals. I got halfway through a book titled An Outsider's Guide to Statically-Typed Functional Programming, which intended to build up a dev's knowledge, starting with Elm and moving to PureScript, and I gave it up for some of the same reasons you started this project.
The Elm portion of that book (all that I completed) might be of use to you, as I think it provides what I thought was a beginner-friendly path that's aligned with your goals. I could be tempted to rewrite the book in NeoHaskell...
P.S. I couldn't join the discord: "Invite Invalid
This invite may be expired, or you might not have permission to join."
Send me a DM on Discord to NickSeagull. Some people are having trouble with the link, and I'm not sure why.
Sorry I lost this. I've sent you a friend request.
This sounds very valuable. I love writing Haskell code, but I wasted many hours trying to get the tooling to work for me. In its current state, there's a 0% I can use Haskell at work, because even though I'm competent in the language, it would be irresponsible for me to commit to a language (and particularly libraries) where I have to worry about getting stuck. Not to mention that my coworkers would not be able to contribute and would not be excited to learn entirely new paradigms and syntax (unlike me).
But if the tooling story were clearer and more trustworthy, I would definitely use Haskell more often.
You may take some flack for this, but this is a very good philosophy IMO. Good for you.
Good luck :-)
What about Elm? Elm sounds like a stripped version of Haskell. Simple and reliable, I would also add that it's not difficult to learn. The only tasks that's left is to make it a backend language.
Elm is great! In fact, I've given a stab trying to make it a backend language at some point. Still, it is not designed with backend in mind, so there are things that are still rough in terms of DX, like, defining services (as in code-organization), or even, there are tasks that are inherently imperative, like scripts, and processors.
Yes, Elm could be modified to support that, but in reality, Haskell already supports all of Elm (except anonymous records, but that's solvable), as well as the other good stuff for backend dev.
On top of that GHC is a great compiler that is very extendable, as well as a great performant runtime.
My theory is that by transmuting Haskell into NeoHaskell will have a much better outcome than trying to make Elm something that it wasn't designed for :)
You've made a good point of Elm's design not supporting backend from the beginning. Thanks.
what an awesome work, I'm thrilled to see this evolving, I have a lot of curiosity with haskell but couldn't get my head around it
Continual satisfaction is really desirable :-) . My only concern is that the return of reverse Polish notation won't bring it to me....
I sincerely hope your languages can be for Haskell what Elixir became for Erlang. Users before anything!
Share and enjoy!
Where do you place this within roc and gleam and others in related spaces?
Roc and Gleam are projects that I've tried and I'm excited about :)
The thing is that they are new ecosystems on their own, and I wanted to build something within Haskell, as I believe it has a lot of potential, and it is already being used in production :)
You mean NeoHaskell being a simpler (yet as powerful) version of Haskell could use all Haskell's libraries?
Correct! Think of NeoHaskell for Haskell as Elixir for Erlang :)
It will limit the things that you can do, but also it will allow you to do other stuff, while retaining the possibility of interacting with all Haskell's libraries :D
The reason I was asking this precise question about Haskell libraries, wouldn't the person deling with Haskell librarie know Haskell itself? Meaning the person will eventually grow out of NeoHaskell because of using Haskell's ecosystem. Or it could be used irregardless whether you know Haskell or not?
So, the idea is to be a parallel ecosystem that leverages the Haskell one. Yes, at the beginning it will be harsh (same as when Python libraries were beginning and had to interface with C. But with time, the ecosystem will be NeoHaskell
NeoHaskell in other words: The discipline not to get advanced with Haskell. At the end of the day, Haskell is, first and foremost, a research language and many people are tempted to apply its cutting edge features, which understandably make things overly complex.
I don't see it as that. The issue is not being advanced or not (in many languages they are doing advanced things with reflection, meta-programming, and other stuff) the thing with Haskell is that it is rooted in math concepts that are tangent to the world of software development. In C# folks are using LINQ without knowing what a Monad is, or Express.js middlewares without knowing what a Monoid is.
NeoHaskell is focusing on software development and pragmatism, removing the nice to haves
This post has rainbow puke all over it...
I had to laugh heartily at "oh, yes, I didn't implement anything yet" and "I'm the one who calls the shots" one paragraph before that. Good luck but I won't be holding my breath. Better advocate for Scala 3 I guess.
Some comments have been hidden by the post's author - find out more