1. 2

    Ergodox-EZ with MX Brown switches

    A heavily modified layout based on Dvorak; many of the ideas from ZenTron:

    • moved up all the keys by one to gain access to more keys under thumbs
    • little finger optimization

    My keymap is here if you hate yourself.

    1. 1

      Very nice!

      Took a while to notice, but I find all the content glued to the left side with a small margin very weird, but I guess that simply shows how primed I am towards github/gitlab in how a directory structure for a repo “should” look… and easily fixed with CSS, so nevermind

      2 things I noticed:

      1. When looking at a file, e.g. https://smithy.honza.ca/smithy/tree/master/include/404.html

      in the

      ref: master
      include/404.html
      

      the “include” folder should probably be linked, otherwse all you have is the back button. - https://smithy.honza.ca/smithy/commit/5997e10eade2d7461f217ea752c0a136713c84f0 is even worse as there’s no link back to the log.

      1. When I go to https://smithy.honza.ca/doom-emacs/tree Chrome wants to translate from Welsh…
      1. 1

        Re 1, yes, totally agree, thanks!

        Re 2, can’t really help you there :)

      1. 11

        That looks very nice indeed.

        It would meet my requirements if it had a clone address coded into the display. Given that you’re already setting details of each repo in the config, this could be an easy fix?

        1. 5

          D’oh, how did I miss that?

          1. 6

            Nice to see, new work in this space. Congrats!

            I’m also working on something similar. I initially launched as a web front-end for Git repositories like CGit. It is written in Go

            Dogfooding it. https://git.nirm.al/r/sorcia

            But now, I’m working on collaboration feature where people doesn’t have to have an account in an instance in order to contribute. This way, I think it will be light-weight without any pull-requests features like Gitea.

            What I’m trying to do here is: Sending patches instead. I’m just doing a brief here:

            1. So, a contributor will generate a patch using ‘git-format-patch’.
            2. Upload it via the web interface or use the CLI utility which I’m going to build.
            3. Verification will be that they will have to confirm their email address.
            4. Contributor’s patch will get into a moderation queue for administrator or repo members who have permissions to check the patch and move it to the review queue for anyone to review the patch and apply it via the web interface.

            I’ve written about this in detail here https://gist.github.com/mysticmode/e07802b949af5985964f25d2cffcae5f

            1. 3

              Sorcia looks really nice. What do you think about forgefed?

              1. 1

                I’ve been looking at forgefed for a while. As well ActivityPub and ActivityStream. But it makes Sorcia a bit complicated. As I said, I need it to be lightweight.

                Maybe for discovery purposes, I might use AP. If I really wanted to make it federated or decentralized per-se - I’d actually stick to IPFS

                I got to know about IPFS through this article.

                It was written 5 years ago but it is still relevant and interesting to me.

              2. 1

                It would be nice if it worked without JS, like cgit typically does.

            1. -6

              I would never use this.

              1. 12

                Pro tip: I stop myself from writing similar comments on half the threads here (esp. the ones involving vim or emacs.)

                Try it! It gets easier with time.

                1. 3

                  Cool story bro?

                  Edit: At least give an interesting rant about what this does that you hate, or what it’s missing that you love.

                1. 2

                  Nice article. I guess I was waiting to hear the result though - did you end up using Haskell/Purescript? From the sounds of it maybe not?

                  It’s a conundrum I’ve wrestled with recently. Where I currently work we have a few components I believe would suit Haskell particularly well, and as a relatively green fanboy of the language, I would relish the chance to get some real production use out of it.

                  Not only that but I’ve discussed it with my immediate superior and he would be open to persuasion. However, as a pragmatic lead developer, I haven’t been brave enough to fully push for it. I know I am nowhere near expert-level and would struggle to teach a full team on it. We could learn together (good smart team of senior developers) but there’s an obvious trade off in productivity for some unknown period of time, and it would require a reasonable amount of enthusiasm from everyone to dive in.

                  My current plan is to continue working through @bitemyapp ’s book (http://haskellbook.com/) to see if that eases some of the learning pain, and find a suitable chunk to bite off and suggest for work.

                  I guess I don’t have much of a point to make here, just that this resonated with me.

                  1. 4

                    The goal with the book is to get people to a place where they can do practical projects (not the only goal, but a big one).

                    My recommendation is to start making toy projects after the book and try to get some breathing room at work where you’re allowed to get stuck on an prototype. Mistake I see people make is to do something high stakes just as they’re getting comfortable. Most common mistake is not asking for help, so please do ask for help! If you’re comfortable with IRC, #haskell and #haskell-beginners have friendly souls, otherwise, my email is on my Github. I may not have time to address your problem in detail but I should be able to get you pointed in the right direction.

                    Hope you’re enjoying the book :)

                    1. 2

                      Thanks for the advice - I only hope I can find that breathing room ;)

                      I will certainly reach out on IRC or to you when I hit any stumbling blocks. I’m really enjoying the book currently, just wish I had more time to dedicate to getting through it. Having messed around with Haskell for a while, some of the challenge is making myself work through everything, even the parts I think I know - just to make sure I don’t miss some key intuition or lesson to be extracted. Great work though, and thank you for the book.

                    2. 2

                      did you end up using Haskell/Purescript?

                      I’m not going to stop learning Haskell because it is hard. I’m definitely thinking about where Haskell might fit in our infrastructure: we have tons of Python and some Clojure. I seem to think that Haskell is quite well-suited for small services (ie the opposite of Rails or Django).

                      So the answer is yes, we’re open to the idea of Haskell but maybe not just yet.

                      I’m glad to see that this post has resonated with so many people.

                    1. -1

                      10ms? I find that hard to believe. That service must not be touching a database.

                      1. 1

                        I find this a bit silly. Only using the type signatures of functions to build your application is a bit irresponsible because you are purposely ignoring the function’s implementation and its implications. Maybe the function uses the wrong kind of algorithm, maybe it’s really inefficient, maybe it doesn’t actually do what you think it does.

                        Also, in Haskell your function’s implementation can use functions that aren’t passed as arguments. You can really run into some nasty situations that way.

                        I also watched puffnfresh’s video, much of the same.

                        1. 2

                          How does the code get inserted into the running application? Surely, this can’t work for a large number of domains of applications.

                          1. 2

                            In the video, I think the REPL is an Emacs buffer backed by some extension that hooks up to a Clojure nrepl instance. When he saves the file, the webserver process reloads it without restarting. But you are right that this style of development requires the language runtime to support hot-code loading. Clojure and several other LISPs have this facility, as does Erlang.

                            1. 1

                              Its a very common idiom with Smalltalk and other image based environments as well.

                          1. 3

                            A while back, this video was instrumental in my grokking monads in Haskell. People usually make you believe that they are something very hard to understand. They are in fact fun and not that hard. I really like about Haskell is how all IO operations are confined to the IO monad. That concept alone changed the way I think about programming.

                            1. 1

                              I rewatch it every few months to keep things fresh in my mind.