My career is well established at this point. I’ve been working as a developer of some sort for over a decade now. I think your advice is still solid though. Thanks.


        YES YES YES

        A simple and easily customizable front-end is what I’ve always wanted.

        I would just like a way to easily have private repos while also being able to view them. From my brief foray into cgit, seems like I’d have to set that up myself.


          Advent of code is nigh, so I’m thinking about how I’m going to approach it. Last year I ended up with quite a few pieces of code being reused and just existing as part of one Elixir project. This worked nicely.

          This year I’m thinking of going with Python. I’ve been using it for (algorithmic) coding challenges and am feeling familiar enough now.


            I find Gwern’s website aesthetically pleasing. There was a similar website I came across related to essays about philosophical debates which I regret not bookmarking.


              While Koka has these features built in, there’s a number of Haskell libraries such as polysemy, fused-effects, freer-simple and eff that you can use in a practical setting to great effect (pardon the pun).


                More worryingly async made our program a lot more unpredictable and hard to reason about: because every time we dispatched async we released the execution context until the work item completed, it was now possible for the program to execute new calls in an interleaved fashion in the middle of our methods. This led to all sort of very subtle and hard to debug ordering bugs

                To me the async vs. threads is sort orthogonal to the main issue with concurrency, which is global mutable state, or more generally nonlocal mutable state.

                If you don’t have nonlocal mutable state, then both threads and async are easy. If you do, then they’re both hard.

                “Ordering bugs” means “some state was mutated by someone I didn’t know about”. Well if you have a disciplined program structure, and you don’t pass the state to that piece of code, then it won’t be able to mutate it. I always trace my state from main() to reason about who else can modify it.

                That is, programs need to keep control over their state. But many/most non-concurrent programs aren’t written that way, which makes it hard to graft on concurrency.

                The way I do that is with dependency inversion of state, which means using zero mutable globals. State is an explicit parameter, which is basically functional programming. You can do functional programming in OO languages.

                Another way to think about it is that some classes are like “threads”, and some are like “data”. If you pass the same piece of data to two different threads, then you need some kind of synchronization. If you don’t, then no synchronization is necessary.

                Oil has zero globals, except for signal handlers and garbage collection state. Shells are only a little bit concurrent though – it has to deal with processes finishing in an indeterminate order, and signals. But still I find maintaining that discipline useful.


                And I would say that what’s nice about coroutines is that they allow you to turn global / nonlocal state into state on the stack. So they are useful tool to reduce nonlocal mutable state, but they don’t address every use case. I have only done a little async/await, but it seems like they basically have that flavor, with perhaps a few more exceptions.


                  The idea was not necessarily about programming, but about abstraction in general (which you call “thinking”) as one of the suggestion is to learn how to program.

                  But I believe that if you are a programmer you will benefit in learning abstractions from other domains as well. I know this has help me in my life in programming and in connecting dots in different ways. Math of course is good, and will help you a long way in programming but not necessarily when you develop a complex system in “weird” business landscape.


                    I haven’t done any Perl in a decade, so my memory might be clouded by time. I really miss Mojolicious. It’s such a well thought through framework/library. Things really fit together. It’s not just a pile of features and it’s also not that heavy weight trying to do everything opinionated framework.

                    If someone wants to work on or does work on a web framework/library, even when having nothing else to do with Perl, I think it’s worthwhile to take a look. Hard to put into words, but it’s extremely well designed. It also does an excellent job of adapting to your needs if you just want to do a small single file project or a large software project. So it goes both the Sinatra and the Ruby on Rails way - not completely though for the RoR side.


                      Interesting. The fixed function encode/decode hardware thing seems especially relevant for e.g. the H.264 decision made when you just couldn’t cram as much on the chip. On the other hand, HEVC and AV1 are both way trickier codecs moving more pixels, so maybe hardware has had to run just to stay in place.

                      Definitely lower requirements for one ‘keyframe’ image than a real video encode. AV1 and HEVC intra both seem heavy enough that hardware can make a real difference even for still images. JXL and/or WebP2 may end up light enough to be more tolerable in software.

                      Apple’s also mentioned worries about submarine patents as a reason for not supporting formats. AOM seems to have done about as much as can be done about them (building on existing codecs, member patents, legal review, defense fund) and JXL/VPx/WebP have tried to be royalty-free too (and VPx/WebP seem to’ve succeeded?).

                      An optimistic thought is that maybe the VP8/9 support really is a sign, and in a gen or two Apple bakes AV1 en/decode into their chips, and then AVIF comes ‘free’.

                      We’ll never know, but I wonder if there’d’ve been adoption of a WebP VP8->VP9 update when VP9 came out. VP9 seemed like enough of a step up to more often justify the work server side to handle an extra format, and Apple did (finally) accept both formats.


                        I am not a subOP, but I have moved from Rails to Phoenix and never looked back.


                          For me Phoenix with Elixir solve most of these problems. It is still mostly opinionated, but with ease you can change that behaviours, it encourages proper separation of the application logic, it uses repo-pattern instead of the ActiveRecord, etc. Of course, it is less popular, so finding hires is a little bit harder, but if you look within community (which author is strongly suggesting) then there should be no problem with finding people.


                            Thank you! I’m not sure if all programmer positions are like this, but I didn’t really look for this job, so I’m guessing I won’t be having trouble finding different ones in the future ^^


                              Hm I feel like this article is mixing up several different things.

                              First four are: Program, Patterns, Concepts, Theories. OK sure, those are related to abstract thinking, although the advice is a bit vague.

                              A few others are: Arts, History, People, Treks, Business.

                              Uh I would call those things you could study to make you a better thinker, period. It doesn’t have that much to do with abstraction IMO (or at least abstraction in programming, which is what the article seems to be about).

                              Also, I think it’s missing an important piece of advice for programmers: study an undergrad level of pure math. That will help you abstract.

                              You will learn what properties are logically necessary to deduce other ones, and which ones aren’t, and how to express yourself succinctly, and abstractly.

                              Related thread: https://news.ycombinator.com/item?id=23692840


                                I agree with the author here, but, playing devil’s advocate, it is sort of handy to have a tool you can whack a lot of problems with, then move on to other problems. I’m not one of these, but I’m guessing a machine learning practitioner could whack this with a few ML hammers pretty quickly, get something working, then move on to other problems. ML seems to be doing an okay job at “general hammering”

                                I guess another way of saying that is that I’m not sure this is true:

                                These polynomials are obviously much faster than a neural network, but they’re also easy to understand and debug.

                                If you’re on a team of ML people who are very comfortable hitting everything with pytorch, maybe the pytorch solution is easier?


                                  Depending on your machine, real-time encoding might be the bottle-neck?


                                      Sounds like decisive step backwards!


                                        Didn’t know about generalized linear models, thanks for the tip


                                          While technical content was low, it wasn’t non-existent; the article covers aspects of web development such as cross-browser testing, fingerprinting, the pitfalls of browser features such as lazy loading, and command-line image optimization utilities. It also seemed relevant given that the 250 kb club recently got attention on lobste.rs.

                                          Of course, I might be wrong; whether or not this is relevant isn’t up to me. If other readers agree that this isn’t relevant, I’ll keep that in mind in the future and perhaps use a different tag or forum for similar content. I don’t think we should remove this post given the discussion that has followed.

                                          CC @cmcaine