Is anyone on mac OS using Alacritty as their daily driver? I’m eager to get away from iTerm2 even if just because the increased sanity of my dotfiles because of the YAML configuration format instead of a constantly modified plist!


      I recently switched to Terminal.app (the builtin terminal) from iTerm2 because it’s slow for no reason. I used none of the features of iTerm2 often enough to warrant using it. If you’re seriously considering Alacritty as an alternative, then switching to the default terminal would probably work for you too.


        100% agree. I’ve gone from iTerm2 → Alacritty → Kitty, and as mentioned in my other comment, I could probably just use Terminal.app now.


        Been switching a few weeks ago, love it since then. Just note you would need a terminal multiplexer for some features (like tabs, split screen, etc). Also, you could miss the command+click facility to open a link (tracked here). Overall I still find the experience to be better than with the other terminals.


          I did for a few months, using tmux. I like it for the most part (especially live-reloading of the config), but switched to kitty [1] about 2 weeks ago and haven’t regretted it. I switched because while Alacritty is (was?) faster than iTerm2, I would experience a lot of slow redraws in tmux, and some other things. I’ve found kitty to be faster. I honestly could probably just use Terminal.app at this point if I could set up some basic shortcuts correctly.

          [1] https://sw.kovidgoyal.net/kitty/


            I have been using iterm2 for years and never had to edit a plist file. What are you doing that requires that constantly?

          1. 6

            jo is pretty rad, too. It handles creation of JSON much easier than jq.

            1. 2

              The problem is jq is becoming a standard and working its way into a bunch of mainline scripts. I wish someone would write a book on it. I can do simple queries but find some of the syntaxes to be impenetrable.

                1. 1

                  Linking to the manual isn’t really helpful. Do you have other more insightful resources to offer?


                    None. But I found the manual to be excellent. There’s even examples for almost everything.

              1. 1

                Do you have any recommendations to do the reverse?

                1. 8

                  You want to destroy JSON?

                  1. 1

                    This comment mentions gron.

                1. 3

                  I’m speaking on code review at Code Daze in a couple of hours and seeing one of my employees speak tomorrow at it, too.

                  I just launched a new Pittmesh website last night!

                  1. 5

                    I’m relaunching pittmesh’s website. It won’t look much different but the new codebase is far slimmer thanks to Leaflet.js and its support for GeoJSON, a thing that existed but wasn’t widely used when I did the site initially several years ago.

                    I’ll probably also be hacking on Homebrew a bit. I’ve picked up some reviewing for it as an exploration of being an active contributor or maintainer.

                    Lastly, Abstractions conference planning is in full swing so I’ll be looking for sponsors and working through my speaker shortlist.

                    1. 1

                      Current known companys hosting links to illegal content:

                      Fedora Project - sks keyserver
                      OpenSUSE - sks keyserver
                      MIT - sks keyserver
                      communityrack.org - sks keyserver

                      there are alot more i have not checked but these are the easy to spot one so far

                      1. 1

                        What content is illegal in this case?

                        1. 1

                          the magnet links, if you look at the cases of kickass torrent and any other entity that hosted these links, they where taken down and pulled through the legal system with prejudice. If this continues they will not treat key servers any different, especially when they are seen to do nothing about it. There is no good outcome for this.

                          1. 4

                            A magnet link is just a hash with tracker URLs appended. What torrent websites did was host the trackers themselves, which is probably a bit different.

                            That said, I’m pretty sure they would be treated the same way in the legal system. It might be hard to make a distinction between distributing a file hash and distributing a list of computers with the corresponding file.

                            1. 2

                              What judiciary – from any country – has ruled that hashes of a file are illegal? Under what jurisprudence is distributing a representation of copyrighted content or its address, but not the consumable content itself, illegal?

                              1. 2

                                IANAL and I don’t know of a precedent, but the devil’s advocate would point out that sometimes it’s about the intent. If you have hashes of illegal content, there’s very little you can do with it legally.

                                Not quite conspiracy to commit murder, but are there any legal scholars here who can answer this question?

                                1. 1

                                  IANAL, but it’s quite obvious that otherwise legal objects can be deemed illegal depending on circumstances.

                                  For example, in many countries alcohol is legal to possess and consume, but the production thereof and sales to minors is restricted. So selling or giving away alcohol to minors is a crime.

                                  The problem here isn’t the hashes themselves - the (possible) problem is that the service providers (the one’s running the SKS servers) can be deemed responsible for their use in finding and downloading content deemed infringing.

                                  edit clarification.

                        1. 3

                          For codebases with a concrete version, e.g. libraries or binaries shipped to customers: git tag -a #.#.# && git push --tags, then CI picks it up and runs the normal checks and tests followed by deployment to our artifact hosting system or our content delivery system.

                          For codebases that are continuously delivered, a new release is built on every master merge. After successful checks and tests, CI builds a Docker image and pushes it to our internal artifact hosting system as well as Amazon ECS ECR. Right now, it’s a manual step to go log in to ECS and stop the running task for the service that was just released. We’re looking into ways to automate it (and I’d love some suggestions).

                          1. 2

                            I’ll be enjoying my last weekend outside of a software conference planning cycle for the next year. Abstractions 2 is in one year from this weekend (or next, can’t remember exactly) and I’m hosting my fellow organizers for a kickoff barbecue next weekend.

                            1. 4

                              My sense from using Scala professionally for the past approximate five years has been that most of the interests in building out tooling, infrastructure, etc. in that community are predominantly business-driven. That is, the Scala community tends to produce accelerators as a side effect of business need, not ars gratia artis, as many other communities do: Haskell, Rust, Go, etc. Or, somebody produces something once and doesn’t update it and doesn’t have the resources or skills to build a community around a much used project. This is not a condemnation of maintainers who don’t maintain, but rather a failure of the Scala community to produce a group of curators — people who will take on the load when maintainers abdicate —as well formed and intentional as many other communities have, or a culture of curation. “Disarray” is too strong of a word, but as someone who moves between four languages daily, I can compare communities and their resources pretty well and conclude that my technical decision to use Scala is sound while the political decision frustrates me at times.

                              1. 4

                                I think it couldn’t be farther from the truth.

                                The main source of the embarrassing cycle of “Hype – Failed Promises – Abandonment – The Shiny New Thing – Hype – …” is in fact coming from the academic side.

                                To be clear: I’m not blaming students that they drop their work and completely disappear the minute they handed in their thesis, and let other people deal with the consequences. That’s just the way it is.

                                The problem is the ease with which they can get things added to the language/library, especially compared to the scrutiny outside contributions regularly receive.

                                This pattern has repeated over and over, and I think it’s one of the unchangeable parts of the language/community.

                                If you care about a quality, documentation, tooling, then Scala isn’t the right language for you. Simply because “we managed to ship a new version of Scala without breaking every IDE” is not a topic you can write a paper of.

                                1. 1

                                  This is a very important point and I’m glad that you wrote it out.

                                  Would you say that the Scala ecosystem has a continuity problem because businesses and academia are focused primarily on the now and not necessarily building the road ahead for the community and then maintaining those roads once built?

                                  1. 6

                                    Think of it like this:

                                    The core open-source community is the pizza dough that provides long-term stability and maintenance, and the academia/businesses provide the toppings.

                                    Some languages have a large base of long-term, open-source contributors – they are family-sized pizzas which can accommodate a lot different toppings. People can get their favorite piece, everyone is happy.

                                    Scala is different. It has barely any substantial open-source contributors remaining – and everyone is fighting over the toppings to be placed on that coin-sized piece of pizza dough. As a result the kitchen is a complete mess, and nobody is happy.

                                    Scala’s problem is not the focus of businesses or academia, but that it doesn’t have any focus on it’s own.

                                    There is literally no one left (since Paul walked away) who is able to establish or uphold any kind of technical standards, or tell people “no, we are not adding another 6 new keywords to the language”. Heck, they couldn’t even get their compiler test suite green on anything newer than Java 8, but they kept publishing new versions anyway since 2017!

                                2. 2

                                  conclude that my technical decision to use Scala is sound while the political decision frustrates me at times.

                                  Of course you would claim it’s sound, but is that objective? What do you base that decision on? Genuinely curious here.

                                  1. 2

                                    Thanks for asking. I based my decision mostly on architectural analysis with a healthy dose of personal experience. We’re building a new product with cloud and on-premises components. Originally, I’d intended to build everything from scratch but my team identified some OSS that did 100% of we needed with some extra complexity in managing it. The trade-off was a much faster time to delivery in exchange for playing in someone else’s sandbox and by their rules. That aspect was worth it but I lament not being able to write it all in Scala!

                                    However, our cloud services are written mostly in Scala. We have a few stateless microservices for which Scala was a great fit: high-performance OOTB for what within six months will be ~500 req/s and within two will likely exceed 4,000 req/s for one component with another being far more I/O bound. We’re integrating heavily with ecosystems that have Java libraries and we’ve found decent Scala wrappers that give us idiomaticity without building and maintaining them ourselves. We could have used just about any stack for these couple of services but Scala’s enabled us to express ourselves in types and exploit the advantages of functional programming. I’m chasing the holy grail of “it’s valid because it compiles” but we’ve got enough unit tests to complement our design that I’m pretty sure we’re on the right track.

                                    One notable failure was on service that is primarily a user-interactive web app. We had two false starts with Scalatra, which we’re using for the other services, and Play! before switching to Ruby on Rails (temporarily) out of frustration with documentation, lack of examples, lack of drop-ins like what are commonly available in the Rails ecosystem, from whence I came many moons ago. We chose Rails because of the component owner’s experience with it as well as my experience with it and JRuby, knowing that if we started to implement any shareable logic, we could do so in a way that all of our apps could consume. We learned about Lift too late and http4s and some others didn’t give us the right impression for a web app. I just learned about Udash last week and it may be a candidate for replacement. However, it’ll be several months: even uttering R-E-W-R-I-T-E would be kiboshed from on high at the moment as the component does what we need right now.

                                    Moving forward, we’ll be looking at moving some of these services to http4s, etc. once more of my team is comfortable with more hardcore Scala FP. Writing AWS Lambda functions in Rust is also on my radar, as a part of our on-prem product is written in Rust.

                                    1. 1

                                      Out of curiosity, did you evaluate Elixir? The obvious draw is the Ruby-like syntax but it seems that the Phoenix framework has a great concurrency story on top of being a Rails-inspired ‘functional MVC’ framework.

                                      1. 1

                                        There was a running joke on my team and another about us throwing everything away and doing it all in Elixir! I mused about it a little but decided that we were better off in RoR because we can hire for it more easily if we ended up committing to the RoR implementation long-term and because we could run RoR on JRuby as a transition step back to Scala, should we have enough business logic to merit a shared implementation. So far, the latter hasn’t been the case since the app is 95% CRUD.

                                        I’d really like to see an analysis of the websocket concurrency story of Elixir, Scala, and Rust, with perhaps some others for more general applicability. Our app is using good ol’ fashioned HTTP requests right now but we’ve identified some opportunities to shave some transfer overhead by switching to websockets eventually.

                                        1. 1

                                          That’s funny. I guess Elixir has some visibility in this space. I’m planning to use it to build a proof-of-concept. For me it’s the developer experience, combined with the performance and concurrency profile. Here are some comparisons: https://hashrocket.com/blog/posts/websocket-shootout

                                          More results available here: https://github.com/hashrocket/websocket-shootout

                                          1. 1

                                            Thanks for those. I’m sad that they’re out of date but the info is useful nonetheless.

                                  2. 2

                                    I don’t think that’s fair at all. There are a number of actively maintained projects that are at the center of the community.

                                    I do think there are relatively few well maintained libraries outside of that core, but I think that’s a result of the community being relatively small, and the escape hatch of having java libraries available to do almost everything.

                                    Community (non corporate) projects and organizations:

                                    • All typelevel projects
                                    • monix
                                    • Scalaz
                                    • Sbt
                                    • Ensime

                                    All widely used, all with large contributor bases.

                                    Additionally the alternative compilers, scalajs and scala native.

                                    1. 4

                                      At least from my perspective it seems that:

                                      • Typelevel is more busy in dealing with US politics than writing software,
                                      • Monix is largely a one-man show,
                                      • Scalaz is one of the main departure points for many people that move to Haskell,
                                      • Sbt is so great that everyone is trying to replace it, and
                                      • Ensime …? You just literally read the article by the Ensime creator.
                                      1. 2

                                        I do think there are relatively few well maintained libraries outside of that core

                                        The Scala community does have a solid core and near-core extension community. I consider libraries like Monix, Cats, and Scalaz to be nearly a part of the standard library because of how often they are used. sbt and ensime are important but they’re not exceptional: every stack needs a build tool and editor integration. These are solid now, and I appreciate the work that goes into them. Frankly, it wasn’t until sbt hit 1.0.0 that I considered it ready for widespread use because of its obtuseness/unergonomic interface prior to then. I’m eager to see what Li Haoyi’s mill will become.

                                        Things I’ve noted in the past that I’ve found in a less-than-desirable state compared to other stacks:

                                        • Internationalization - fragmented ecosystem, sbt plugins outdated
                                        • Authentication & Authorization - no nearly drop-in solution like Devise in the RoR ecosystem
                                        • Project websites being down for weeks because someone forgot to re-up the TLS cert, even in a LetsEncrypt automation world
                                        • Out of date documentation to the point of being dangerous practices with little more than a “someone submit a PR to fix that”. I get that maintainers get busy but when safety is the topic, is it acceptable to wait for a drive-by contributor to get it right and contribute the correction? What if they do that and then no maintainer merges it for years?

                                        The Scala Center has the promise of addressing much of it but I speculate that it’s insufficiently funded to be the ecosystem plumbers and teachers it aspires to be. I’ve been impressed with its work so far, though.

                                    1. 4

                                      For folks like me who’ve been running the experimental Metal renderer for a while, I think this is the same one.

                                      1. 1

                                        I wasn’t on beta, so this is nice to know about!

                                      1. 37

                                        I think practically all “Why You Should…” articles would be improved if they became “When You Should…” articles with corresponding change of perspective.

                                        1. 23

                                          An even better formulation would be “Here is the source code for an app where I didn’t use a framework. It has users, and here are my observations on building and deploying it”.

                                          In other words, “skin in the game” (see Taleb). I basically ignore everyone’s “advice” and instead look at what they do, not what they say. I didn’t see this author relate his or her own experience.

                                          The problem with “when you should” is that the author is not in the same situation as his audience. There are so many different programming situations you can be in, with different constraints, and path dependence. Just tell people what you did and they can decide whether it applies to them. I think I basically follow that with http://www.oilshell.org/ – I am telling people what I did and not attempting to give advice.

                                          (BTW I am sympathetic to no framework – I use my own little XHR wrapper and raw JS, and my own minimal wrapper over WSGI and Python. But yes it takes forever to get things done!)

                                          1. 2

                                            Thanks for the Taleb reference. I didn’t know it existed, and so far it is a good read.

                                            1. 1

                                              His earlier books are also good. It is a lot of explaining the same ideas in many different ways, but I find that the ideas need awhile to sink in, so that’s useful.

                                              He talks about people thinking/saying one thing, but then acting like they believe its opposite. I find that to be painfully true, and it also applies to his books. You could agree with him in theory, but unless you change your behavior then you might not have gotten the point :-)

                                              Less abstractly, the worst manager I ever had violated the “skin in the game” rule. He tried to dictate the technology used in a small project I was doing, based on conversations with his peers. That technology was unstable and inappropriate for the task.

                                              He didn’t have to write the code, so he didn’t care. I was the one who had to write the code, so I’m the one with skin in the game, so I should make the technology choices. I did what he asked and left the team, but what he asked is not what the person taking over wanted I’m sure.

                                              In software, I think you can explain a lot of things by “who has to maintain the code” (who has skin in the game). I think it explains why the best companies maintain long term software engineering staff, instead of farming it out. If you try to contract out your work, those people may do a shitty job because they might only be there for a short period. (Maybe think of the healthcare.gov debacle – none of the engineers really had skin in the game.)

                                              It also explains why open source code can often be higher quality, and why it lasts 30+ years in many cases. If the original designer plans on maintaining his or her code for many years, then that code will probably be maintainable by others too.

                                              It also explains why “software architect” is a bad idea and never worked. (That is, a person who designs software but doesn’t implement it.)

                                              I’m sure these principles existed under different names before, and are somewhat common sense. But they do seem to be violated over and over, so I like to have a phrase to call people on their BS. :-)

                                              1. 2

                                                Yeah, the phrase works as a good lens and reminder. Interestingly, as most parents will attest to - the “do as I say not as I do” is generally unsuccessful with kids. They are more likely to emulate than listen.

                                          2. 2

                                            I definitely agree with this change. It’d get more people thinking architecturally, something that’s sorely needed.

                                          1. 10

                                            Google usually tells everyone what the best way to do things is

                                            Why is this?

                                            I speculate that it may be because organizations of its size have the resources – budget, mostly – to do research. They’ve been right enough that the industry tends to trust them without individually vetting everything that they do. Maybe there’s a hefty amount of cargo cult around it, too: it works for Google, so it’ll work for we common folk, and they tell us that it works so we believe it even more. It’s sales of a different kind.

                                            1. 3

                                              I’ve used ScalaCheck in the past but I’m not actively using it presently out of expediency.

                                              I’m really interested right now in finding a tool that can look at a database table (MySQL currently) and generate records for it. I’m slowly tracking down a bug that seems to affect how some data is stored by a third-party app whose database I’m having to access directly (long story). Finding a tool that could just generate some rows would save me a lot of time.

                                              1. 3

                                                I’m surprised that the author managed to follow around 5000 (if I understood the article correctly) people on Twitter. it seems like the amount of noise on your feed would make it unusable at that point.

                                                1. 2

                                                  I’m following 867 and my timeline is too much sometimes. I follow virtually no celebrities, a few politicians, a handful of the StockTwits old guard (the whole reason I joined Twitter 10 years ago), and a whole lot of tech people.

                                                  1. 1

                                                    Agree. I try to give myself a limit of about 400, because that’s the point where I’ve noticed that it becomes unmanageable. Right now I am following 525, and am overdue for some pruning, but I’m not sure how to do that effectively. :/

                                                  1. 3

                                                    I asked an applicant to a job posting I had open to complete a short 30-minute coding exercise when they didn’t have any public code available. Really, they had no Internet presence except for a barebones LinkedIn profile.

                                                    They provided their code test result as a git bundle and specifically called attention to their commit history. I was thoroughly impressed. It was like they’d memorized Deliberate Git, my favorite talk about git etiquette. Their code was great and the story the commit messages told was enlightening. They got an interview.

                                                    1. 1

                                                      They got an interview.


                                                      1. 2

                                                        Why? Singular they is a thing.

                                                        1. 1

                                                          When you don’t know their identity (see what I did?). “Whoever broke in cleaned their tracks”.

                                                          It causes confusion when used in cases like this.

                                                    1. 13

                                                      One thing that a co-worker drilled into me about 5 years ago now was to accept that code is fundamentally communication. The code that you work on every day is not written for you, it’s not written for your boss, it’s not even written for your customer. Your customer wants a product or an experience, they don’t care about the code that comprises it.

                                                      Your code is written for the person who’s going to come back to it 3, 6, 9, or 36 months from now wondering why things aren’t working the way they think they should be then, and trying to understand what the mindset was right now at the moment you’re writing it.

                                                      This mentality should drive naming. It should drive design. It should drive documentation. It should drive even the most basic assurances about how you understand your code to function now, including some of the libraries that you consume and rely upon. That’s a fancy way of saying tests.

                                                      So, code isn’t just about being a sponge for technical documents, the latest frameworks, and the cool new tools. It’s about clearly communicating your present mindset for consumption by somebody else.

                                                      Here’s an actionable exercise: write an program — Conway’s or ENIGMA or something — and come back to it in a year.

                                                      1. 1

                                                        What is the impact on not-that-old Mac games that are unlikely to be updated?

                                                        1. 2

                                                          I find literate coding to be one of the best ways to learn. I wish more folks did this. My big takeaways from this are the existence of Tango and static_http_cache.

                                                          I wish there was more tooling support for literate coding. What are some IDEs, editor plugins, etc. that facilitate literate coding?

                                                          1. 2

                                                            For this project, I didn’t have any special editor support, but I did heavily rely on entr to trigger converting Markdown to HTML whenever I saved in my editor, and livereload to trigger my browser to reload whenever the HTML file was updated.

                                                            It may seem minor, since neither operation is time-consuming, but before I found those, there were so many times I’d forget to do either or both steps because I was busy thinking about how best to phrase something. It’s been said many times before, but lowering the iteration time of any creative endeavour is always immensely positive.

                                                          1. 3

                                                            The product that I’ve been working on for the better part of a year is going into production this month. This week, we’re figuring out the deployment automation parts. We’ve decided on Terraform, so we’re learning about it and finding a lot of solid examples for how to deploy our several services to AWS.

                                                            1. 1

                                                              What’s the stack you’re working on? Our team has looked at Terraform and Cloudformation in the past but decided on using Jenkins and Ansible instead. Working with NGINX, PHP 5.6, MySQL 5.6, Redis, and Cloudfront over here.

                                                              1. 2

                                                                Mostly Scala: Scalatra + Jetty, with no database for any part: two apps are acting as A&A for S3 buckets, while the other is A&A for a Kinesis sink. We have another part that’s Rails atop Postgres but we’re keeping it in Heroku until we get the other components stable. There are some other teams within my org that are Rails shops. Everyone’s doing something a little different so we’re going to powwow in June about a unified deployment methodology and platform.

                                                            1. 3

                                                              A tool I’ve used that’s pretty great is tj, which has convenient colored output and some more configurable output options. This example with Docker shows a little of what it can do visually.

                                                              1. 12

                                                                You basically copy-pasted the article I wrote from http://2f30.org/guides/openbsd-httpd-cgit.html . The referenced link in your post is wrong (typo 2c30 -> 2f30). Booo!

                                                                Here is the most up-to-date version (as linked from 2f30): https://codemadness.org/openbsd-httpd-and-cgit.html . It has some notes to make cgit tarball snapshots working.

                                                                A related article for git hosting: https://codemadness.org/setup-git-hosting.html

                                                                Edit: thanks hir0 for updating the article! It is totally fine now.

                                                                1. 5

                                                                  I will admit I used a lot of the advice on your blog post to help me set up my server. I’m sorry it came across so copy-pasted. I’ve added a section to the top of the post to make it very clear that this post wouldn’t exist without your work. Also, sorry about the typo, that’s fixed now.

                                                                  1. 1

                                                                    Are you suggesting this is plagiarism?

                                                                    1. 3

                                                                      Quickly comparing the two, the submission is actually less helpful than the parent comment’s article, which says what stuff to install. The submission leaves that exercise to the reader.

                                                                    2. 1

                                                                      Just wanted to drop by to say thank you for writing that article. I’ve been running my own git server for a couple of months now.

                                                                      Now I only have to find one for setting up an email server ^_^.