learn4haskell VS hadolint

There are a lot of really good "learn by doing" initiatives out there which are also theory heavy, even in the hardest languages (like this kind of thing for Haskell). Learning by immersion is the way they teach language in a hurry, and to learn a programming language in a hurry immersion is still the best teacher (in the form of a lot of hands-on projects that force you to handle theoretical concepts to complete them). It's not just the fun of making things and problem solving, but also of putting the big picture together and increasing what you can do. I bet you can find immersion projects like that on GitHub (or the internet in general) for almost any language or framework (and good textbooks are similar).

If you’d like to have the team look at free learning material to gage team wide adoption, I created a video series that used this really nice repo https://github.com/kowainik/learn4haskell

If reading books isn’t exactly your thing, here are some Haskell courses that should get you writing Haskell as fast as possible. There are two options to choose from here: something like Type Classes or learn4haskell can be very useful for getting started with the Haskell syntax and basic language constructs, while the more university-focused courses from Erik Meijer or Graham Hutton will help you start thinking like a functional programmer.

I think you might benefit a lot from going through short materials like Learn4Haskell. Your questions are all answerable there.

If you are already advanced in other programming languages, this course will get your feet wet: https://github.com/kowainik/learn4haskell

I am doing this course https://github.com/kowainik/learn4haskell is from a past event, but in my opinion, the content is excellent and I am loving it so far, also the repo owners still check and give feedback which I think is amazing

For Haskell most people read a book, http://learnyouahaskell.com/ or few other ones, I went through a bit but I started loosing focus just reading. This https://github.com/kowainik/learn4haskell helped me to get through that, really nice gamified learning path.

Learn4Haskell - Great for getting your feet wet with Haskell's syntax, and the fundamental typeclasses. They teach the concepts, and give you exercises on Haskell files which I find really neat. Akin to vim tutor. You can also run test cases which I found helpful.

To skip the "move your scripts to standalone files" step some devs don't like, consider something like https://github.com/hadolint/hadolint which runs Shellcheck over inline scripts within Containerfiles.

This is neat :)

I love going and making containers smaller and faster to build.

I don't know if it's useful for alpine, but adding a --mount=type=cache argument to the RUN command that `apk add`s might shave a few seconds off rebuilds. Probably not worth it, in your case, unless you're invalidating the cached layer often (adding or removing deps, intentionally building without layer caching to ensure you have the latest packages).

Hadolint is another tool worth checking out if you like spending time messing with Dockerfiles: https://github.com/hadolint/hadolint

With Depot, we make use of two Dockerfile linters, hadolint and a set of Dockerfile linter rules that Semgrep has written to make a bit of a smarter Dockerfile linter.

# Download hadolint wget https://github.com/hadolint/hadolint/releases/download/v2.12.0/hadolint-Linux-x86_64 # Download SHA256 checksum wget https://github.com/hadolint/hadolint/releases/download/v2.12.0/hadolint-Linux-x86_64.sha256 # Validate the checksum sha256sum -c hadolint-Linux-x86_64.sha256 # Make the file executable chmod + ./hadolint-Linux-x86_64 # Rename the file mv hadolint-Linux-x86_64 hadolint

The most common linter I've seen and used it Hadolint, which does: https://github.com/hadolint/hadolint/wiki/DL3002 I didn't bother checking to see if alternatives also support this as well though.

Some discussion on that here:

https://github.com/koalaman/shellcheck/issues/58

The hadolint project does shell checking for Dockerfiles and it uses shellcheck:

https://github.com/hadolint/hadolint

So the approach is definitely feasible, but you do need a new project and probably it needs to be written in Haskell.

how does this compare to something like hadolint?

Also, have you run across Hadolint for linting? https://github.com/hadolint/hadolint