1. 2

    I track what I’m doing through making a posteriori calendar events on a caldav server. I track a prioritized list of things I want to do in caldav tasks.

    1. 4

      Companies defeat this using open floor plans, no? Otherwise super cool.

      1. 3

        I’m surprised. I’ve seen misleading Kafka docs before (claims to support exactly once delivery but small print saying something like exactly once delivery semantics for idempotent processing), but I actually assumed ordering within a partition worked. I’ve used NSQ for years and I’ve always pointed out in comparisons that Kafka has more guarantees about your data so Kafka is the right tool if you need those guarantees.

        Now I’ll think that much harder about using it.

        1. 1

          For idempotent processing, you just need at least once. Is that what they meant?

          1. 1

            That’s what i get from it. I mean, if message processing is idempotent, you don’t really care about exactly once, just as long as it is at least once.

            1. 1

              I haven’t seen “at least once” and “exactly once” used equivalently in the Kafka docs, but “exactly once” does have subtly specific meaning.

              The major asterisk is that it only applies when consuming from and producing back to Kafka itself. Note that “committing your offsets” is a form of producing, as these are stored in the special __consumer_offsets topic. Essentially you wrap the commit of your offsets and the produce in a transaction so that both are persisted, or neither. This allows you to, say, relay messages from one topic to another exactly once. It’s not magic, though — if the processing of the messages has side effects those may be repeated!

              https://kafka.apache.org/documentation/#upgrade_11_exactly_once_semantics

            2. 1

              Kafka is extremely complex and that sort of thing makes me very uncomfortable with any guarantees they put on the tin since there always seems to be a lot of asterisks on guarantees in extremely complex things.

            1. 4

              The city where I live allows for a maximum of two dogs per household. Three dogs, as far as the city is concerned, is too many dogs.

              1. 5

                Time for regime change.

                1. 3

                  Where is that?

                  In the US, limits on the number of dogs in a household were struck down in a district court decision a long time ago but many cities still have the law on the books and enforce it tactically, knowing that not a lot of people would try to fight it despite a precedent that may or may not apply in their judicial district.

                  1. 2

                    That sounds familiar, but a district court would only have impact on…well, the district. If it had then been appealed and denied ceriorari at both the appellate and Supreme Court level, it’d (within at least the narrow confines of however the decision was written) potentially have national appeal, but otherwise, it’d have been a local decision. Do you know the case, or anything about it?

                    1. 1

                      I may have misremembered the scope. I thought it was a federal court decision, but it appears that it was a Pennsylvania Commonwealth Court decision. So, it only applies to PA.

                      http://www.naiaonline.org/articles/article/pennsylvania-court-strikes-down-ordinance-limiting-number-of-cats-per-resid

                      There are other cases, such as one in Minnesota at the MN state level, too. I know that there is not case law declaring such laws unconstitutional in Kentucky, as an acquaintance of ours lives just outside of Louisville because Louisville has limit and breed laws that are apparently aggressive enforced. A contact in the metro government there confirmed this.

                      Breed clubs and responsible breeders have better info on this, such as on https://omalmalamutes.com/omal/doglimits.htm, from an older AKC bulletin on the subject:

                      Several courts have agreed that limit laws are unjust. In 1994 the Commonwealth of Pennsylvania struck down an ordinance enacted by the Borough of Carnegie that limited residents to five cats or dogs per household (Commonwealth of Pennsylvania v. Creighton, 1994). Similarly, a two-dog limit in Sauk Rapids, Minnesota was challenged and ruled unconstitutional (Holt v. City of Sauk Rapids, 1997).

                      The modern AKC position is documented in http://images.akc.org/pdf/GLEG02.pdf. More info here: https://animallawcoalition.com/are-you-a-victim-of-pet-limits/.

                      Source: family breeds and I’ve had litters in my house yearly for the last several years. Entering it by relationship, I’ve covered all of my bases. Limit laws are still on the books in most municipalities, preferring citation of case law should the educated plaintiff take the matter to court. Uneducated law enforcement presents a risk to dogs with complex medical and behavioral needs.

                  2. 1

                    Considering carbon footprint impact of dogs I would limit myself without waiting for the city to enforce.

                  1. 15

                    There’s something cool about having a whole community on one machine. It’s like we’re all on one space-ship. We share the same silicon. The bits stay on the mothership.

                    1. 7

                      If you are on the same machine, finger and .plan work just as well, no need to reinvent them. ;)

                      1. 3

                        The beautiful thing about the tilde-verse, which you’d never know until you have an account there and use it, is that it’s like a giant art experiment.

                        People build things out of sheer whimsy, and other people use them and share in that whimsy. The result can often be quite beautiful in ways that are hard to find on the larger intertubes.

                        This is a fine example.

                        Could you use plan and finger? Kind of, but that wouldn’t create a timeline like this does, or collect all the .plans together in a ‘feed’.

                        1. 4

                          Could you use plan and finger? Kind of, but that wouldn’t create a timeline like this does, or collect all the .plans together in a ‘feed’.

                          There would definitely be value in building those things on top of .plan/finger.

                          1. 1

                            I disagree, but we’re getting into my personal ideas about what these things “should” be used for.

                            In my experience, your .plan file is where you advertised who you were and what you worked on in a general sense. While you could make your .plan this incredibly long rambling affair, I feel like there are better mechanisms for doing this sort of thing, and Dustin has written one.

                      2. 3

                        You should check out cosmic.voyage. It’s quite literally what you’re describing.

                        1. 2

                          I’ve never heard of this, it sound amazing. Thanks for sharing :)

                        2. 2

                          This has fun privacy implications too. I’d like my social network to better model my actual meatspace social network. The problem, of course, is that people have many different meatspace social networks.

                          1. 2

                            Except the physics of computer security, esp covert/side channels, make that impossible. You’ll always be more private if your friends are in a room together instead of on a server. Especially if there’s obstacles to seeing or hearing things that people can optionally use.

                        1. 4

                          I’ve had trouble in Mac OS, this slowed down the terminal’s start time some. I’m pretty sure it’s not asdf’s problem specifically but it was a significant slowdown

                          1. 2

                            Is there an issue on the issue tracker for this? I think we recommend using brew --prefix or something like that in the docs for finding the right path, but it’s really slow. Much better to hardcode the path. I’ve got some plans to simplify asdf and make the install process easier.

                          1. 9

                            My wife and I are looking for inspiration for a family website and we’d like to see cool stuff around the internet.

                            I’m only responding to voice my opinion that it’s immoral to publicize children’s lives, especially before they’re even born.

                            I know a lot of sites that come to mind will be personal branding sites, but we’d be especially interested in cool concepts for family sites, too.

                            I may as well. I prefer my own website; it’s free from modern WWW nonsense, which happens to be worse than classic WWW nonsense. Since I’m mentioning any, I also like Richard Stallman’s personal website.

                            1. 3

                              I’m only responding to voice my opinion that it’s immoral to publicize children’s lives, especially before they’re even born

                              As am I, however since the birth of my Son, my wife and I have realised we’re firmly in the minority here. It can be difficult to keep pictures away from facebook et all as most people do not have similar concerns. However without more context a family website is a broad description that could cover lots of difficult scenario’s.

                              1. 2

                                I have four kids, and I wish there was an easy way to keep tabs on my family (people getting married, having kids) without resorting to Facebook, with everything defaulting to private. And hopefully I could host it myself somewhere. Anyway. I see the use case. I want my not-tech-savvy aunts to be able to see pictures of my kids, because in pre-internet, I would just have mailed them pictures. There’s a private case.

                                1. 2

                                  It’s an interesting problem, I tend to send pictures over whatsapp or icloud private shared albums. I’m not particularly happy with those either as one is linked to facebook and the other is still a massive corporate behemoth. I would love to try a private site with pictures behind a login but I fear that would be wasted effort for my non tech savvy side or even worse - I would be forever dealing with login issues for them!

                                  As mentioned previously - I’m in the minority, lots of people are happy having everything in the open.

                                  1. 1

                                    because in pre-internet, I would just have mailed them pictures

                                    Email?

                              1. 4

                                Working on a library for doing deep copying in Go. We don’t need to do it often at $work, but when we do, it’s super inconvenient and error prone to write it out by hand. (Or, if that’s too annoying, we have hacks that just gob encode/decode to get a deep copy, when it works.)

                                The best library out there for this, as far as I can see, is copystructure. But it’s not particularly configurable and doesn’t help with unexported fields.

                                1. 1

                                  I don’t program in Go. Can you please explain what an unexported field is. Also, just curious what problem space has you deep-copying data?

                                  1. 2

                                    It doesn’t really have anything to do with the problem space. You just occasionally want to be able to copy stuff, for example, when you want to ensure nothing shares any memory. Kubernetes has its own bespoke code generation tooling for this, and HashiCorp uses copystructure in a lot of their stuff AIUI.

                                    But yeah, unexported fields just refer to the visibility of members in a struct. One can only access unexported fields within the same package in which the struct is defined. Reflection based tools normally respect this, but deep copying is often orthogonal to the visibility of struct fields, particularly since you might want to deep copy something that has unexported fields. Since copystructure doesn’t support this, you wind up having to annoying role your own manual and error prone deep copy implementation for structs with unexported fields, or you wind up just exporting stuff so that it plays nice, which obviously isn’t ideal.

                                    1. 1

                                      I wish there was an interface and/or de facto standard for this. Then you can just implement what it means for a thing to copy itself at that thing’s level, and anything wrapping that can just internally call the “Copy” of what they wrap.

                                      1. 1

                                        It’s tricky to just use interfaces to solve this problem. The first issue is that the natural type signature of a copy method is something like this:

                                        func (t T) Copy() T
                                        

                                        But you can’t express that in Go in an interface, so you wind up with this:

                                        type Copier interface {
                                            Copy() interface{}
                                        }
                                        

                                        … which is obviously less than ideal, and makes it a bit annoying to use.

                                        Second issue is that even if you accept the interface{} here, it’s still a major pain to actually write out the implementation of it. It’s a place in the code that’s just waiting for hard to diagnose bugs and it’s hard to unit test effectively. The simple case where this falls over is when you add a new field to a struct. There’s nothing that will actually tell you that the new field also needs to be added to the Copy implementation for that type. You’ll only find out about it when some other piece of code uses the Copy method and a subtle bug crops up because your copy doesn’t include everything.

                                        You can devise unit tests that will fail, but you need another piece of machinery. That is, you need something that says, “fail this test if this value has any zero values in it.” That way, you can write a test that asserts your Copy routine roundtrips correctly and will also fail if you add a new field to a struct but forget to update both the test and the Copy implementation.

                                        My idea here is to take a page out of go-cmp’s book and look for methods with the type signature, func (t T) Copy() T and use that before falling back on to automatic reflection based machinery to do the copy. That way, types can precisely control how they are copied when necessary, but otherwise, a Copy will “just work” in the common case.

                                      2. 1

                                        Cool thanks. Ah it sounds like the problem space is distributed computing, or short lived tasks or containers in this case, which Go is suited for.

                                        I do alot of web development and outside of maybe cloning an online Order or some basic strings I don’t do this much.

                                        Recently the only copying I’ve done programmatically is to “clone” a tables from db server 1 to server 2 as apart of an adhoc task. Interestingly enough usually I do this via insert into select from statements, but recently learned of Federated tables in Mysql which make the cloning even task between distributed mysql instances easier. Again, in this case as you’ve noted sometimes cloning has shortfalls. In Mysql a Federated table has various limitations such as limited allowed DDL statements on the table, or certain password character limitations.

                                      3. 1

                                        An unexported field is basically a private field in a struct. Unexported fields are only visible within the package they are defined in.

                                        1. 1

                                          Thanks

                                      4. 1

                                        Oh, cool, so you’re still writing Go! Good to know. I somehow though you’re a Rust-only celebrity now ;D Good luck regardless, anywhere the Road takes you! :)

                                        1. 1

                                          Yeah I never stopped. I just don’t typically do it in my free time any more.

                                          1. 1

                                            Given your experience in both, I admit I’m now quite curious what are your thoughts on pros & cons of each? But no pressure or whatever; suppose people often ask you about this ;)

                                            1. 13

                                              That’s kind of a loaded question. :-) People don’t actually often ask me that question. A real answer is probably pretty involved. Personally, I think the most important benefit of Go is its “simplicity.”[1] And by that, I mean that it is very easy for people to hit the ground running with Go without too much fuss at all. There are a limited number of constructs available in the language, so it’s in general pretty rare to stumble into something that’s difficult to understand because of its abstraction. (My own experience supports the pithy phrase, “abstraction solves all problems, except for the problem of abstraction.”) If code is hard to understand, it is usually, at minimum, concrete, such that it doesn’t require thinking carefully through sophisticated type system shenanigans. The only truly complex Go code I run into is either deeply reflection based (which is pretty rare outside highly reusable shared libraries) or a mess of goroutines using a non-standard concurrency pattern. But I’ll take that over the pthreads code I’ve seen in C any day.

                                              Of course, like any good trade off, its strength is also its weakness. When you bump into Go’s abstraction limits, it can sometimes be really annoying. For example, I often really want a generic Option type that encodes the possibility of absence—even if it’s only enforced at runtime—since it isn’t always the case that the zero value is a useful indicator of absence. e.g., Dave Cheney’s famous “functional options” article uses the fact that the default value of 0 can also have meaning in a particular domain, so it isn’t sufficient to treat 0 as “missing” (and thereby resort to some other default). This in turn serves as part of a motivation for avoiding configuration structs entirely. Of course, you wind up with more machinery, but this can be worth it for a highly reusable library.

                                              Rust also has abstraction limits, but I very very rarely run into them in the work I do. Of course, those limits are much much higher than Go, and as a result, using the language is itself much more complex. I personally think it’s still comfortably less complex than using Haskell, and definitely less complex than using C++, but it’s pretty clear that it takes a lot more ramp up time to get started with Rust than it does Go. This has not only been echoed by many other people that have tried Rust (“I gave up a couple times before succeeding, and now writing Rust is not that hard” is a common story), but is also consistent with my own personal experience teaching both Go and Rust. I’ve helped people learn both, and the number of times I needed to go to a whiteboard and carefully explain a somewhat dense snippet of code is markedly different between the languages.

                                              Obviously, this trade off is intentional. Rust isn’t complex for no good reason. There are super good reasons for almost all of its complexity, and they generally boil down to some combination of safety and performance. Go also values safety and performance, but not nearly to the degree that Rust does. In Rust, I can push a lot more invariants into the type system quite naturally and idiomatically, where as with Go, the language actively fights against encapsulation (in the “data hiding” sense) in a lot of circumstances. Again, this comes down to complexity. For example, it’s totally reasonable to want to write your own type that exposes a map-like interface—and maybe uses a map internally or maybe not—but this is just fundamentally impossible because the language blesses the map type with special syntax. You can see this clearly even when the standard library struggles with it, for example, the sync.Map type and its Range method. Moreover, if you’re hiding things, this completely destroys the utility of most of the ecosystem’s reflection based encoding/decoding infrastructure. You wind up having to write error-prone serialization goop if you want to hide your internals. (Error-prone because if the internals change, e.g., with an additional field, then you have to remember to update the serialization goop. It’s possible to write unit tests for this, and we have them at work, but that in turn requires knowing to add the field to the test to serialize in the first place. So we have test helpers for that which can check that all values in a particular type do NOT have the zero value. So if you add a new field, that test automatically fails.) So… encapsulation in Go is possible, you just wind up getting punished for it, so sometimes you invariably choose “encapsulation isn’t worth it” just because of how the language is designed, instead of what makes sense for you specific circumstances. The frequency with which this happens is annoying in my experience. In Rust, I almost never have to make this sacrifice; encapsulation is well supported and nearly effortless compared to Go. (I could articulate some cases where Rust punishes you too, but that gets into the weeds and they are fairly rare.)

                                              [1] - I purposely use the word “simple” in quotes, because people love to imbue their own definition of what “simplicity” means. e.g., You’ll see plenty of people arguing that Haskell is actually “simpler” than Go just by comparing their core language specifications. e.g., The full generality of Haskell makes it “simple.” I don’t think this perspective is 100% wrong, but it just completely misses the very obvious point I’m trying to make and completely derails the conversation into a brain-dead definitional turf war. That is, I think it’s completely uncontroversial to state that, as an observation, it is much easier, in general, to read, write, learn and productively use Go than it is Haskell. I don’t give two poops why that is (“it’s because we don’t teach functional programming as a first language” is a common refrain) and I don’t care if it isn’t true in some cases, because, obviously, individuals vary.

                                              1. 8

                                                This comment is far too good to be buried in a weekend update thread. :)

                                                1. 2

                                                  Thanks a lot for the response! And for your time taken to write it. Sure, I know it’s kinda loaded ;) but of all the people, who could be better posed to try and answer it in a balanced way than you! ;) As such, it carries a lot of value and authority to me.

                                                  Personally, I’m currently kinda licking my scars after a first stroll into the Rust land. What surprised me most, is I think that it felt more complex than C++ to me; but I’m kinda coming to terms with the fact that it may just be because how far I got in C++, and how used to it I’ve become. Also, I was taken by surprise by the fact, that my difficulties weren’t with borrow checker per se, but rather secondary and tertiary consequences of BC on the typesystem coming at me from the least expected angles. With all that said, and with your report as an important point, I’m kinda starting to think I may just need to come back to trying a few more times in future, until I’ll maybe grok it at some point. But also my appreciation for simplicity and readability of Go is reinforced by your explanations.

                                                  One more question, if I may: would you risk comparing the languages on a scale of “malleability” (ease of change), when some new features require deep refactoring of existing codebase? Do you find Go easier, Rust more supportive (b/c invariants in types), or do those kinda balance in your mind? You can answer by PM, or plain refuse to, if you’re afraid of being quoted on this in flame wars ;)

                                                  1. 2

                                                    Personally, I’m currently kinda licking my scars after a first stroll into the Rust land.

                                                    I think that’s okay! I’m aware of a lot of people bouncing off Rust, at least initially. But I’ve heard a lot of success stories where people come back to it and figure it out.

                                                    What surprised me most, is I think that it felt more complex than C++ to me; but I’m kinda coming to terms with the fact that it may just be because how far I got in C++, and how used to it I’ve become.

                                                    Possibly. I am not a C++ practitioner, so it’s hard for me to say too much. I would hazard a guess that the presence of ubiquitous UB would bring its complexity above Rust almost on its own. In most Rust code that I write, I don’t need to think about UB at all, and I probably write more unsafe than most (since a lot of my work is in core libraries). With that said, I think this is a big rabbit hole, because C also has lots of UB, and I could see an argument to be made that C is simpler than Rust in the same sense that Go is simpler than Rust. It’s a pretty hand wavy thing in general, and I think “unknown unknowns” probably plays into this quite a bit. That is, I think a lot of people who write C or C++ are probably not intimately familiar with the language lawyering necessary to think carefully about whether some piece of code is actually UB or not, so the presence of UB might not contribute to the perceived complexity of the language.

                                                    C++ also has a lot of other crud in it, and its template system is, I think, at least as complex as Rust’s parametric polymorphism facilities. But alas, we could circle the drain on this one forever. :-)

                                                    One more question, if I may: would you risk comparing the languages on a scale of “malleability” (ease of change), when some new features require deep refactoring of existing codebase? Do you find Go easier, Rust more supportive (b/c invariants in types), or do those kinda balance in your mind? You can answer by PM, or plain refuse to, if you’re afraid of being quoted on this in flame wars ;)

                                                    Hmm, good question. I haven’t thought about this one as carefully as I’ve thought about my encapsulation issues detailed in the previous comment. I think both languages ultimately make refactoring substantially easier than languages without a static type system, at least in my experience. I realize reasonable people might disagree on this, but it’s been reinforced for me personally many times throughout the years.

                                                    In terms of Rust vs Go… I guess I honestly feel like refactoring is generally pleasant in both languages. I suppose, as you’ve guessed, I have found Go a bit harder to refactor in some cases, but this mostly ties back into my encapsulation argument in the previous comment. That is, sometimes I’ll just give up on encapsulation completely in Go for a particular type, and just expose its internals. Even if I think it’s the “wrong” thing to do all else being equal, you really just do not want to fight the language too much, so you have to pick your battles. In some cases, an exposed representation can make it awfully difficult to rigorously enforce an invariant. Even something as simple as imposing a “fail fast” change where you check an invariant on some piece of data on access is hard when everything is exposed, because you can’t control the access in the first place.

                                                    Anyway, that’s all I’ve got for now. Please accept my thoughts with an appropriate grain of salt. I’m waving my hands a fair amount here. :-)

                                                    1. 2

                                                      Thanks. As to UB, sure, that’s what finally scared me away from C++, but I started finding out about it only once I was quite deep, unfortunately :( And I too fully believe much too many people still don’t grasp well enough what it means. In part it feels to me like many people don’t want to believe; I assume in part being subconsciously afraid of losing so many years of experience when switching tech stacks. Also, before Rust, there was no serious alternative. So, personally, I too hope Rust would eventually replace C++.

                                        1. 4

                                          A shame that it focused more on the hardware side of things, instead of his experiences with Plan 9.

                                          1. 2

                                            Agreed. I wanted to hear about how you set up the whole cluster, how it runs, conceptually and effectively how do login and permissions work. I never could run a plan9 correctly, protecting the access to local resources by password.

                                          1. 36

                                            This is a post I’d started writing on a brief vacation stint, and came back to and finished tonight.

                                            I hope it helps people, and I’m sorry if it doesn’t improve the discourse on the subject. :(

                                            1. 15

                                              There is one more that I would add to the list of burnout-inducing items:

                                              The loss of trust. Organizations change over time and it sometimes happens that they fail to live up to previous standards. This, combined with any visible progress (or even negative progress) is a surefire way to stress people out and make them leave.

                                              Which was the reason why two other team members and me handed in our notice last month after spending years with this unspecified company. The final straw was when the CFO of the company called one of us, who was on medical leave in a hospital at the time, to talk about timesheet-related paperwork. We resigned within a week after that incident.

                                              1. 9

                                                Congratulations on your departure! Show the bastards they can’t get away with that behavior, and make it hurt.

                                                1. 8

                                                  Thank you, although I hope that the company in question learns from this and improves.

                                                  My mindset is that I always prefer to work on gentlemens terms. However that means respect and trust has to go both ways. It’s not something you write on a mug, it has to be actively practiced.

                                                  1. 2

                                                    Funny that you say that: I just received a mug with my company’s slogan yesterday!

                                              2. 10

                                                Masterpiece. Bookmarking my favorite write-up on the subject. Bravo!

                                                1. 7

                                                  It helps.

                                                  1. 4

                                                    Thanks for sharing.

                                                    1. 3

                                                      It’s an awesome post. I wish I could write like that.

                                                    1. 5

                                                      I don’t know about you, but these days my work mostly involves navigating around a huge code base, finding relations between classes, identifying where to do the change and then write some code. Thus most of these editors seems to be focused at writing lots of code fast when what I need the most is going around and finding my way in the code fast.

                                                      So while I may save some time with Kakoune’s editing pattern, I will lose much more if I don’t have a reliable “Go To Definition”.

                                                      1. 2

                                                        Kakoune has an integration for the langserver protocol, which gives you that fairly reliably, I find. Maybe not as good as full-blown IDEs, but I’ve found it more than good enough for most cases.

                                                      1. 1

                                                        The sqlite aspect seems great, and also scary. But, perhaps backing up the file every 10s to s3 gets you to “meh, it’s pretty reliable.”

                                                        oh wait! It still supports etcd, so nevermind

                                                        1. 1

                                                          Doc apparently says that it’s broken somehow? I’m not sure. I understand nothing.

                                                          1. 3

                                                            Yeah. I dug in more. Looks like a lot of things are currently broken, and this is early stage. Not shocked by this—still seems really neat and useful!

                                                        1. 11

                                                          If you’re going to birth a new programming language in this era, can you please make it not be named a single letter? Pretty please. This makes searching for things about the language much harder than it needs to be.

                                                          1. 6

                                                            I told the author. They’re thinking of names but running into the “already taken” problem. Probably still thinking on it.

                                                            1. 4

                                                              Yes, name suggestions are welcome. I guess it’s best to come up with a new word that makes sense and is google’able. Like Scala.

                                                              1. 1

                                                                I was going to suggest Volt but found that exists. Another systems language trying to be better than C. These things are popping up everywhere. Might be better to consider something other than one starting with V. Not to say there isn’t something in the dictionary waiting to be discovered.

                                                                1. 1

                                                                  I went through 10 names, all of them were taken by other languages :)

                                                                  Volt was my initial idea too. Although it’s weird having the same name for the language and the product.

                                                                  1. 1

                                                                    Nothing wrong in having name collisions with other projects.

                                                                    (Nothing wrong in single-letter names either, but if you would prefer not to have one you shouldn’t let the lack of unique names stop you.)

                                                                    1. 1

                                                                      I got the same feeling yesterday.

                                                                    2. 1

                                                                      Yeah, I thought about that. Might get you two things in top of Google, though. Probably better if they’re different.

                                                                      Far as taken, remember that there’s endless ideas that have been tried in the past that nobody will think about or use. New products keep showing up with some of the same names. Quite a few get big. The conflict caused no problems since the older thing didn’t matter. So, you might still be able to use an existing name if it’s a project with no attention whose owner isn’t likely to sue you. You could give that great name the reputation it deserves. :)

                                                            1. 22

                                                              How common is this sentiment? I feel exactly the same way about my career.

                                                              1. 12

                                                                Absolutely. With only minor changes, such as s/Apple-dev/Ruby-dev/ and s/written books, //, this is basically my current struggle as well. :(

                                                                1. 11

                                                                  It is very common with people who burned out and have not yet recovered.

                                                                  1. 10

                                                                    What if it’s not burnout, and the industry really does suck and keeps getting worse?

                                                                    1. 3

                                                                      The suckage of the industry is certainly a problem. But being burned out definitely not making you appreciate any extra.

                                                                      1. 1

                                                                        How did you help to recover from your burnout. How do you avoid relapsing?

                                                                        1. 1

                                                                          I first changed position internally in the company. Then moved to another company, industry sector and country. But it wasn’t exactly a specific plan and far from a controlled experiment.

                                                                          Afterwards I looked at the things that got me there and nipping them in the bud since. Mostly it’s saying “no” early and firmly to unreasonable things, and dismissing unsolicited input from people who are not stakeholders. That includes ignoring the work of non-coding architects. But it’s circumstantial, there are likely many paths leading to burnouts.

                                                                    2. 5

                                                                      This is what burnout feels like?

                                                                      1. 7

                                                                        It did feel very similar to me. You know how to do the job, it’s not like your previous skill and knowledge evaporates. You can make an estimate how long could it take the former you etc. But the battery is dead, you never get anything done.

                                                                        Unlike the OP I didn’t quit right away when it happened, but changed my position from project lead to a grunt doing non-critical part of work. Struggled even with that but was sort of able to push it through. Took about 18 months to recover enough to function.

                                                                  1. 37

                                                                    I’m no longer excited by the technology for it’s own sake. I couldn’t give a shit how many serverless functions your bespoke kubernetes cluster manages, or how simple your webpack configuration is.

                                                                    I find work that matches my ethics; at the moment I’m lucky enough to support radiopaedia.org. We get regular letters from around the world detailing cases where the site has helped save a patient or markedly improve their health, which is always a morale boost.

                                                                    What is there that’s genuinely interesting and exciting in the world of software, and what was your way of engaging your interest and excitement?

                                                                    Software systems get used to plan large-scale infrastructure projects, keep track of clean drinking water, food production & distribution, and healthcare. Being aware of the positive outcomes my work generates has become key to enjoying it.

                                                                    1. 24

                                                                      Some (mostly unfiltered) thoughts on this:

                                                                      This all sounds very familiar. In fact, I resigned a few weeks ago with no new job lined up as I felt my entire job was just useless. Everything gets rewritten every year or so anyway, so why bother?

                                                                      I was rewriting some of the same code I rewrote when I started. When I joined a lot of stuff was objectively bad; for example a lot of the email handling code was so bad a lot of emails simply didn’t get delivered, or incoming emails wouldn’t get accepted (it was written by someone who didn’t understand email). So my refactors served a clear purpose: “don’t drop emails”, “make sure emails are RFC-compliant”, etc. I then refactored things to add some features (“more details logs”, “ability to re-send delivery failures”, etc.) Again, refactors to enable a concrete goal.

                                                                      Later on, we did some refactoring to make stuff compile faster; it was taking upwards of 30 seconds for even simple changes, and it was pretty annoying. This involved rewriting quite a bit of our API, and that took maybe 2 months in total. I’m not sure if it was worth it in hindsight, but at least it had a clear concrete goal (“make it compile faster”), which was measurably achieved. It did make working with the code more pleasant, as waiting 30 seconds for a simple type is no fun at all (fast compile speeds are supposed to be a feature of Go!)

                                                                      But now, I see people rewrite stuff because “it’s more elegant, “it had better layers”, or “this is the best way to do it according to {person,methodology,religion,…}”, which are all really just rephrasing of “I prefer it this way”. This doesn’t mean the new way is bad per se, sometimes I think it’s probably a better approach too, but … the “old” way is working, and often has been working for quite a while. Why rewrite it? “I prefer it this way” is not a concrete goal. What is gained with the rewrite? Often this isn’t clear, and at the same time there’s still the increased workload. Even if you’re not involved in the rewrite directly, you’ll still have to learn the new API and/or way of doing things.

                                                                      This is a product to solve concrete problems for our customers. The code to achieve that isn’t some sort of art project.

                                                                      Yet, many people seem to treat code as an art project. Now, I treat some of my personal projects as “art projects” – and I learned a lot from doing that – but when building software in a team of people that’s just not workable, every time someone new joins the “art project” needs a re-evaluation because it doesn’t fit their sense of aesthetics.

                                                                      Software is easy to change. This is great in some ways, but it’s also easy to fall in to the trap of constant change. If you build, say, a bridge of building you can’t just change it at a whim, even if it has serious problems such as lack of daylight or airflow (far too many office buildings suffer from this), so people accept that the world is imperfect, suck it up, an deal with it the best they can. But in software it’s tempting to say “no, I can make the world a better place! I just need to rewrite [..]!” Sometimes that is the correct approach, but often times it’s not. Especially not if you’re in a team. It’s very hard to actually prove something is “better” in the world of software, so the endless battles/bikesheds start.

                                                                      This isn’t just a software dev problem, it’s also a management problem in the company. But I don’t see that changing, so I just quit.

                                                                      If it was just this company I’d find a different job, but it’s a pattern I’ve seen in many places in my 10-year career. This is not a new observation, either: CADT, Magpie developer, etc. are all phrasings of this problem.

                                                                      I don’t know what I’ll do next; maybe I’ll just go jwz and open a bar or something. I really like building software products, but am thoroughly fed up with the industry. Everything feels like a battle, and I’m too tired of it. It might be worth it if I felt the end-result is worth it, but it’s just regular B2B software. Not the worst in the world, but nothing special either. There are a whole bunch of competing products that do an equally good job (if not better).

                                                                      1. 12

                                                                        If it was just this company I’d find a different job, but it’s a pattern I’ve seen in many places in my 10-year career. This is not a new observation, either: CADT, Magpie developer, etc. are all phrasings of this problem.

                                                                        Every time I’ve seen this happen, it’s at a organisation that has money far in excess of its costs (unfortunately, this happens pretty often in b2b software).

                                                                        This enables middle management to start empire-building / hiring for projects of dubious value. You can fight it in the early stages by having a suitably aware CEO (eg 37signals / basecamp) but as you get to larger organisations, most roles fit this description.

                                                                        Once you have more developers than you need to solve the problem, you start stepping on each others toes and spending all your time communicating; before you know it, there are four teams building microservices (to reduce the communication overhead) to solve a problem that only needed one team of 3-5.

                                                                        You can avoid this by finding a place that either lacks excess money, or has somewhere to sink it. Basecamp sink it into high engineering salaries and dividends to owners; radiopaedia can only afford me part-time, but can hire me for more hours if they get more money.

                                                                        1. 5

                                                                          There is a saying that if everybody are morons, you are the moron. (For clarity, I don’t believe you are a moron, you seem bright).

                                                                          Could something similar be said of battles? If everything feels like a battle, does it come from within?

                                                                          1. 4

                                                                            Okay, some more mostly unfiltered thoughts (I guess Lobsters is my weblog now?)

                                                                            That’s not unreasonable, and I’ve been thinking about that for quite a while during the last few months (even before I resigned). There is an easy solution to it: shrug, don’t care about anything that happens outside of the narrow scope of the job I was hired for, do my boring job for a few hours, and collect the paycheck.

                                                                            But that’s not really how I work. In many companies there’s a lot of stuff “between the cracks”, stuff where there’s no person/team who has a clear responsibility, but really should get done. I tend to do a fair amount of work “in between the cracks” as that’s often pretty valuable for the business. Example: I wrote standard scripts for our Travis integration, because that’ll save everyone a lot of time so they won’t have to ad-hoc the .travis.yaml files with random copy/pasting. I spent a day on it two years ago and while hardly perfect, it’s been working pretty well since then. Yet I’ve had to deal with a ton of bikeshedding and headaches about it. Some of the feedback has been reasonable and constructive (great), but there’s also a lot of “change for the sake of it”, and some downright toxic stuff (like the guy that just overwrite it all several times with his own version without prior discussion, often getting a few key things wrong).

                                                                            Perhaps the worst part if that all the bikeshedding and toxic idiocy made me shoot down a more reasonable proposal that someone made a few months ago. The PR did have a bunch of issues and needed quite a lot of work, but fundamentally it was a good effort as it attempted to address various real concerns (and was’t a “I don’t like the way it’s done” type of rewrite). The entire thing was eventually amicably resolved, but being in the state where I growl at things because I’m tired of bikesheds and toxicity being flung at me is not a place I want to be at.

                                                                            To be clear, the problem isn’t “everybody”, it’s just that there are a few people who have very strong visions on the One True Way™ how to do things and will push that vision with little sense to pragmatism. A lot of people think that’s somehow normal, so these people can do what they want (some of these people are also very toxic).

                                                                            As I briefly mentioned, this is just as much of a management fail as anything. Ideally, management should have nipped a lot of this nonsense in the bud and fired a lot bunch of these people (some of the more toxic ones have).

                                                                            Some examples: I wrote our internal Go framework; this wasn’t a “invent a framework from scratch” effort, but more “codify common practices our existing projects already use, while making sensible ROI improvements”. The end results is pretty decent, if I say so myself. Yet, no one uses it, as it doesn’t fit the One True Way™ for any of the teams. The result is that we now have 6+ “frameworks”, all based in varying degrees on the original. There is loads of duplicated effort here. I tried very hard to accommodate people’s concerns, but there was a lot of “I don’t like it”-ism and people just went of in their own direction anyway 🤷

                                                                            I don’t even have strong opinions. I just care about 6 teams not duplicating all effort to produce a Go API. Not unreasonable, right? But now we’ve got all that duplicated effort. Worse, some of these efforts are just … not very good. We’ve had two unreleased apps that already had to undergo a massive rewrite before release because the re-invented stuff sucked too much, but is being ignored “because I don’t like it”. I get that new apps sometimes need to take risks and experiment, and that some of these risks don’t work out, but this isn’t rocket science, this is basic CRUD APIs. We already invented all of that 2 years ago.

                                                                            I’ve been working on a weblog post about all of this for a while, but I find it hard to articulate my feelings accurately, because when described like above it doesn’t necessarily sound like a huge deal. “So no one uses your framework, deal with it!” In part, it’s a “death by a thousand cuts” affair, this is just one example. There have been a lot of pushes to rewrite/redo existing systems without a clearly stated goal. Seeing a lot of your work being rewritten all the time has a certain psychological effect. Why bother if everything will be rewritten next year, anyway? There was also a good HN comment on that last week.

                                                                            I’m also one of the few that actually takes the effort to push back on all of this. A lot of people seem to shrug in apathy, or they just don’t do anything because they don’t want to spend the effort to get involved. Turns out that actually caring about making a good business, and not just doing the job you were hired for, can burn you down. I’m “just” a developer, I don’t really have more authority than anyone else. In hindsight, I should have either pushed for more authority, or tried harder to get those in authority aboard. Being remote while ~75% of the company is in an office probably doesn’t help either, especially not after I moved to New Zealand which put me in a massively different timezone (main office is in Ireland).

                                                                            Part of this is just growing pains from small startup to company with >250 people. When I joined stuff worked pretty well without any direction, as a lot of people were very pragmatic and dedicated. Now that’s we’ve increased the amount of staff by a lot, things are more tricky. I guess I could work to change the culture, but after 3 years I feel burned out and to be honest, our products aren’t all that great and not really sure if it’s worth is trouble.

                                                                            1. 2

                                                                              What you’re describing here sounds like a bad mismatch between the level at which you care and the level of authority you hold. Plus probably. the proportion of payoff you stand to receive if you do succeed.

                                                                              Put another way: if you’re high up enough in the organisation that you could fix it, it might be your responsibility. If you’re not senior enough to e.g. be able to order people to knock bad behavior off, then by definition it is not your responsibility.

                                                                              Please don’t get emotionally invested in a company of which you are not a large-stake shareholder. It is IME a recipe for getting burned out hard.

                                                                              1. 3

                                                                                I suppose you’re not wrong, but on the other hand apathy and not caring is also quite toxic, IMHO.

                                                                                1. 2

                                                                                  Sure, don’t start casually keying peoples’ cars on the way in or whatever. Care about your work. Don’t try to fix things that are your boss’s (boss’s) job, though.

                                                                        2. 26

                                                                          I’m no longer excited by the technology for it’s own sake. I couldn’t give a shit how many serverless functions your bespoke kubernetes cluster manages, or how simple your webpack configuration is.

                                                                          Here’s why this is so correct: being excited by technology is a surefire way to be disappointed in life.

                                                                          1. 19

                                                                            This kind of sentiment confuses me, especially given the context of this community. If working at a job that matches your ethics is what does it for you, then that’s amazing! We need more people like that around to make the world a better place.

                                                                            But disparaging people for being excited about technology is odd, to say the least. There’s something intrinsically satisfying, at least to some people, about learning new things, understanding the context in which that thing is (or is not) useful, and why it is (or is not) more useful than the old way of doing things. Do you think a mathematician being excited about mathematics for its own sake is a surefire way to be disappointed in life?

                                                                            Treating your software like a craft and always striving to be better is a great way to enjoy what you do. A carpenter isn’t diminished by making tables for whoever happens to want to buy them, they can enjoy their work intrinsically as they masters their craft and take satisfaction in a job well done. Obviously this can be complicated by the reality of working with other people who may not treat it the same way, but… that’s how people work, and that problem exists in any field or career.

                                                                            1. 20

                                                                              But disparaging people for being excited about technology is odd, to say the least.

                                                                              If you get excited about technology, it’s much more meaningful to get excited about how a technology could help people, not about the technology on its own, which most of the time is going to be deployed to sell more ads or perform more effective surveillance.

                                                                              1. 7

                                                                                it’s much more meaningful to get excited about how a technology could help people, not about the technology on its own

                                                                                There is a certain irony to this comment coming from someone with the username “technomancy” whose description links to their blog about their custom-made personal keyboards. :)

                                                                                One way to help people is to not criticize their internal motivations simply because they don’t align with yours. If someone gets home at the end of the day and feels great for no other reason than that they got to write a bunch of code and they love how writing code makes them feel, more power to them.

                                                                                It might be more meaningful to also help other people with your tech, but that has its downsides. When you hang your satisfaction on someone else’s joy, you give others control over your own happiness. You sacrifice the freedom to feel good about something you did just because they happened to not like it.

                                                                                Each of us is free to find our joy however we like.

                                                                                1. 8

                                                                                  coming from someone with the username “technomancy” whose description links to their blog about their custom-made personal keyboards. :)

                                                                                  On the contrary, the reason I have continued to make custom keyboards after all these years is precisely that; it helps people. The keyboards allow my customers to avoid RSI and learn some useful DIY skills. I wouldn’t still be doing it otherwise.

                                                                                  If you look at my comment in context, I’m replying to a post that is explaining why the original poster no longer feels motivation to work in software. If you don’t feel like they do right now, that’s great, but the odds are very good that at some point in your life you will if you’re working in the technology industry.

                                                                                2. 4

                                                                                  Genuinely wondering how you feel about this:

                                                                                  If you get excited about mathematics, it’s much more meaningful to get excited about how mathematics could help people, not about mathematics on its own, which most of the time is going to be used to sell more ads or perform more effective surveillance.

                                                                                  1. 5

                                                                                    which most of the time is going to be used to sell more ads or perform more effective surveillance.

                                                                                    This isn’t actually true for mathematicians as far as I know? I mean, if you’re a statistician working for an ad company, then sure; it seems to hold up fine, but as far as I know most mathematicians aren’t.

                                                                                    1. 1

                                                                                      The “most of the time” probably isn’t (I personally think definitely isn’t, but no data no certainty), but if you’re a mathematician working on something just because it interests you, there is a chance still that someone might find a use for it in ways that you didn’t think about, including ads and surveillance. What I was wondering about phrased directly is basically, whether these two questions have different answers for you:

                                                                                      Q1: Is it meaningful for a mathematician to work on some mathematical structure that interests them, without any foresight of a meaningful use of their work?

                                                                                      Q2: Is it meaningful for a programmer to work a on a technology that interests them, without any foresight of a meaningful use of their work?

                                                                                      where meaningful is relative to you personally.

                                                                                    2. 2

                                                                                      Mathematics is discovered. Technology is built.

                                                                                      When you discover new mathematics, nobody owns the math.

                                                                                      When you build technology for an employer, somebody else owns the technology.

                                                                                      That means:

                                                                                      • Your work can be destroyed by someone else without you getting a say (eg the project discontinued by management)
                                                                                      • Your work can be redirected to only be used in ways you disapprove of.
                                                                                      1. 1

                                                                                        Mathematics is discovered. Technology is built.

                                                                                        This statement is in my opinion too general to have any useful meaning or validity.

                                                                                        I however find your distinction between discovery and invention (building) interesting, so I’d like to ask you a question. Consider a new real world programming language L. It would probably be very easy to argue that L was invented. Assume now that a user of L stumbles upon a quirk in the way L handles closures for example. Is this quirk an invention or a discovery?

                                                                                        1. 1

                                                                                          The quirk is in an implementation; it was invented by the language creator and discovered by the user.

                                                                                          1. 1

                                                                                            What about the behavior of numbers? why isn’t that an implementation detail? if numbers are too natural for you then what about the behavior of sequences of numbers? doesn’t that seem a bit closer to an implementation detail?

                                                                                            1. 1

                                                                                              Whether numbers are an implementation detail is a question for theology 😀. Human understanding of them is a discovery.

                                                                                              1. 1

                                                                                                Whether numbers are an implementation detail is a question for theology

                                                                                                Hehe, I was actually heading in the direction that numbers are defined by humans and not by any divine entity and thus the way they behave is maybe just an implementation detail of how we defined them;)

                                                                                  2. 8

                                                                                    But disparaging people for being excited about technology is odd, to say the least.

                                                                                    My intent was not to disparage and I find that reading to be very odd. All I’m saying is that if you focus on technology as your source of excitement in life you are setting yourself up for disappointment. This does not mean you are a lesser person for liking it.

                                                                                    Treating your software like a craft and always striving to be better is a great way to enjoy what you do.

                                                                                    I take great pleasure in writing software, making keyboards and other such things. I truly enjoy it and I always want to improve. But that is not technology. Technology is just a vehicle for that kind of growth. The technology itself may be interesting and I may like it, but I certainly don’t like it just because it’s technology.

                                                                                    According to the life expectancy measures, I have one foot in the grave (that is, I’m past the halfway point). I grew up in the personal computer revolution and was an adult when the Internet took off. I’ve heard a lot of promises of what technology will do and how it will change things. Only one thing has ever been consistent: it does change things (corollary: we’re terrible at predicting the future). It does this for both good and bad, and rarely in the ways you hope. I used to look for the new thing all the time. I don’t anymore and I’m happier for it.

                                                                                    The joy I get from technology is understanding it and using it so that I can do things or better yet, how it gets used to help people. I don’t get excited about AI/deep learning, for example, I get excited about the thought of learning how it works and maybe using it to help me with my extensive collection of papers. At the same time, I think the adtech world is nothing short of a blight on humanity and have zero respect for it. As such, I would never work in it, regardless of what AI techniques they use. Being excited about AI for the sake of technology, in this case, would cause me great inner conflict and thus, disappointment. To avoid these situations, I no longer seek happiness in technology.

                                                                                    This is one of those topics that is hard to put your finger on and honestly, I don’t think I’ve quite captured it here. I apologize for that. At the same time, I can’t deny that a lot of my friends, just like me, used to be thrilled about new technological innovations, saying things like “Wow! That’s awesome!” or “It’s just like in the movies!”. Now we say, “Maybe a Earth-level EMP pulse isn’t such a bad idea.”

                                                                                    1. 2

                                                                                      My intent was not to disparage and I find that reading to be very odd. All I’m saying is that if you focus on technology as your source of excitement in life you are setting yourself up for disappointment.

                                                                                      Not if they die tomorrow. Sorry for the strong statement, but I just wanted to provide at least one counter example.

                                                                                      People are different, maybe as programmers we need to resist the urge to generalize more than other humans.

                                                                                      1. 2

                                                                                        I wasn’t generalizing so much as playing the odds. (And yes, there are plenty of counter examples. But it’s also not a cut and dried kind of argument, which is kind of the point.)

                                                                                        1. 2

                                                                                          Fair enough, I personally share your sentiment. Thanks for your explanations, you’ve certainly put it in a way better than I could’ve.

                                                                                      2. 1

                                                                                        This is one of those topics that is hard to put your finger on and honestly, I don’t think I’ve quite captured it here. I apologize for that. At the same time, I can’t deny that a lot of my friends, just like me, used to be thrilled about new technological innovations, saying things like “Wow! That’s awesome!” or “It’s just like in the movies!”. Now we say, “Maybe a Earth-level EMP pulse isn’t such a bad idea.”

                                                                                        I’d like to point out that this is the same tendency, expressing itself in opposite ways. If we had an Earth-Level EMP Pulse, people would die. A lot of people. Technologists have a hubris that says “We can do it better, just watch us” that leads to magpie development, technological innovation, and a wish to burn it all down.

                                                                                        1. 2

                                                                                          It’s a hyperbolic statement.

                                                                                      3. 10

                                                                                        There is almost nothing new and shiny that’s genuinely interesting, in my opinion. I derive excitement from learning about new concepts and such that I haven’t previously known about–there’s plenty of that. I do not derive excitement from whatever the current hype is. Elixir? Serverless? Those just feel dull to me. They seem like a cycle: “This is the next great thing! It’s SIMPLE! And FANTASTIC!” and then those folks write software systems that, like most other software systems, suck. Everything is simple in the beginning, and everything is legacy after five years. I think that’s what Geoff was getting at.

                                                                                        1. 4

                                                                                          I think you are describing the toxicity of the hype cycle and the shallow excitement it inspires. The target of the hype, being it yet another software framework, a music genre, or a food, is not relevant.

                                                                                          Trends are almost parasitic: they chase after new idea, feed on the novelty aspect and then leave it behind.

                                                                                          1. 1

                                                                                            I share that, mostly. There’s one problem with this approach I’ve experienced, which is that it focuses on getting fundamentals right (good!) but disregards the importance of getting the superficial details right too.

                                                                                            The reason for e.g. Go being popular is that they got so many little details right, not because it contains new concepts.

                                                                                      4. 6

                                                                                        I find work that matches my ethics

                                                                                        That’s a good suggestion. I think this is why I have been trying to skirt the Free Software world, because I believe strongly in the four freedoms. When I’ve gone for “open source” jobs that aren’t really open source, I’ve always been disappointed (in one, the open source was kept very much at arms’ reach to avoid “accidentally” opening the core IP; in another, I took on the role of defining our open source strategy, getting the internal lawyers and other stakeholders on board, getting buy-in from the engineers…who then didn’t open source anything).

                                                                                        1. 6

                                                                                          Being aware of the positive outcomes my work generates has become key to enjoying it.

                                                                                          This is helpful for me, thanks.

                                                                                          1. 8

                                                                                            Honestly, it’s hard for me to imagine any other reliable way to enjoy work, other than enjoying the company of your co-workers.

                                                                                            You might get some fleeting enjoyment out of solving a particularly tricky logic puzzle at work, but in a healthy workplace there tend to be few opportunities to apply cleverness; people applying a lot of cleverness to their code on a regular basis is a sign of an unhealthy workplace.

                                                                                            1. 5

                                                                                              I get quite a bit of enjoyment from just solving the problems at hand in the most appropriate way. This is way more reliable for me than enjoying the company of coworkers! People come and go, have a bunch of opinions and habits, but GNU Emacs never lets me down.

                                                                                              1. 12

                                                                                                speaking of Emacs, I think there’s definitely something to be said for dotfiles hacking as a kind of “release valve” that allows you to express your cleverness in a way that doesn’t result in unmaintainable code for your teammates!

                                                                                                1. 1

                                                                                                  I like that idea a lot actually.

                                                                                              2. 4

                                                                                                I live in the central US and I’ve met a lot of developers around here who are happy to grind away at an insurance company because it lets them provide their family with a level of comfort other jobs wouldn’t allow. The work itself doesn’t seem to give them a wholesome feeling, but being able to provide for their families does.

                                                                                                This feels related, but somewhat different from your point about the work itself being directly beneficial to society.

                                                                                          1. 12

                                                                                            There’s a lot to unpack, and I’m afraid I won’t be much help for a variety of reasons that I will enumerate. First off, I’m a father of four living in a relatively low cost-of-living area of Quebec, Canada, and we’re lucky enough that my work provides comfortably for our lifestyle, and my wife can stay home and take care of the kids (one of which has had significant health issues (open heart surgery at 2 months of age, yaaaay), I can’t begin to be grateful enough for our universal healthcare). I’ve come to a point where I’m comfortably remunerated, don’t have a lot of consumer debt, and my mortgage is soon gonna be 1.5 times my yearly salary; this is good because it requires a less huge “relative” chunk of my paycheck, and I can manage to do other stuff with my money (specifically, pile it up for projects, debt repayment, or because I’d like to retire one day).

                                                                                            The above is my context. This is why I will bite the bullet and do what I do for money, at some cost in morality. My absolute list of priorities in life put my wife and family’s wellbeing above my own. That might not be super healthy, I’ll grant you that much, but that’s how it is; I have a responsibility towards them, and I very much intend to fulfill it if it’s the last thing I do.

                                                                                            The above is why I stick to my job, at least for durations. Whenever I change jobs, I think “well I’m gonna stay at this one for at least five years”. The average lifespan of my past 4 jobs is in the neighborhood of 2 years. I’m 10 years into this career now, and I’ve stopped expecting corporations to care about me (I think that’s good). I’m not sure how I feel about everything I build essentially contributing to consumerism and either enabling people to buy more efficiently, or sell more things (or sell cheaper, or more efficiently, or whatever). I don’t really have contributions to the open source things. I have a few useless things that I built for myself that are open source, I tell people about projects and try to teach people about things I think are cool, and that helps.

                                                                                            I don’t really have a solution. A friend introduced me to this concept of Ikigai a while back; I really feel like what I’m missing for myself is the “what the world needs” part. I don’t think the world needs us to buy more things. I’ll direct you to my first paragraph as an indication of why I don’t stop doing what I’m doing, which leads back to the next one, and the next one….

                                                                                            I recently shipped a tiny piece of software for a university’s music department that helped its workers by automating a rote time-consuming task. I didn’t charge them much, because there wasn’t much to do; If I wanted to maintain my lifestyle, I’d have to render that same kind of life-improving service 200 times a year, just about. I’m mentioning this because it felt good. I’m helping them save a bit of time so they can do less boring more important work. Next time around I’ll charge a bit more, yes, but I’d like to do more of that. Directly improving people’s lives through automation… IDK. Felt nice, felt like I was actually helping real humans. Nobody’s getting rich off of that piece of code, I can promise you that much. This might be my way out, in the long run. This, I like to do.

                                                                                            1. 7

                                                                                              A friend introduced me to this concept of Ikigai a while back; I really feel like what I’m missing for myself is the “what the world needs” part.

                                                                                              Same here. The wikipedia page translates Ikigai as “the reason for which you wake up in the morning”; I wake up because I need the toilet. That’s a useful framework though, and gives me a way to think about what I should be waking up for. Thank you!

                                                                                            1. 1

                                                                                              I can manage most of what seems promised by tilt through docker-compose and docker. What am I missing? The magic?

                                                                                              1. 1

                                                                                                I think Tilt is trying to specifically solve Kubernetes development.

                                                                                                1. 3

                                                                                                  And Kubernetes in turn was supposed to solve container development/deployment.

                                                                                                  A more cynical person would find humor in this.

                                                                                              1. 22

                                                                                                I feel like it comes to this:

                                                                                                1. Is your web app more like a newspaper, brochure, pamphlet, flyer, or other similar purposes? If so, a SPA is not the right architecture for you. Maybe a small component of that site is, like a comments box or something, but that should be a drop-in widget, not dominate the engine of the site.
                                                                                                2. Is your app more interactive, a desktop app that a user would have had to download and install manually before the web took over? If so, then SPA is probably the way to go.

                                                                                                The first one treats the web like text documents: a URL is a way to retrieve a single view of a document. The second one treats a URL like a document that describes how to load a full application.

                                                                                                1. 8

                                                                                                  What i’m reading in your comment is it boils down to data consumption vs manipulation, which makes sense to me.

                                                                                                  1. 9

                                                                                                    Even manipulation can be done very effectively via traditional HTML forms, and maybe some minor changes. I have seen people use Asana as an example of SPA… but it is a todo list site, and that is really easy to do as a traditional html site (and it would load like 10x faster). Even traditional form + ajax saving - basically the same as the spa user experience - is pretty easy to do.

                                                                                                    I just feel like these easy old techniques are becoming a lost art :(

                                                                                                    1. 9

                                                                                                      Even traditional form + ajax saving - basically the same as the spa user experience - is pretty easy to do.

                                                                                                      Maybe up front, but it’s very, very hard to not make a dogs breakfast of untestable, tightly coupled code. As much as SPAs are maligned, I’d take maintaining an Angular app over a jQuery app of similar UI/UX complexity any day.

                                                                                                      1. 1

                                                                                                        Sure, but that’s a strawman–if I’m reading @adam_d_ruppe’s suggestion, we’re talking a server-rendered page with a normal input form, with just enough Ajax to highlight validation errors and to move page otherwise. That’s hella easy to maintain.

                                                                                                        If you need every little widget and greeble to jiggle and dance when a user does something, sure, pick a framework that does that–but the overwhelming majority of web pages are really just documents and not applications.

                                                                                                        1. 1

                                                                                                          I’d rather an untestable tiny project than a massive overkill SPA that only needs to take about five interactions for users and twenty for admins.

                                                                                                        2. 2

                                                                                                          Fully agreed. I was more interested in the original comment looking at it from the other end: which application definitely does not need an SPA? The answer to that, and it makes sense to me, is seemingly applications where the main usage is going to be data consumption.

                                                                                                          1. 1

                                                                                                            What do you mean by traditional form + AJAX saving? That the form data is submitted by an XHR request, and if there is an error it is rendered on the same page, but if the request succeed then the browser navigates to a new page/URL?

                                                                                                            1. 2

                                                                                                              Basically progressive enhancement.

                                                                                                              If the UI already represents what is saved, it can just save - just like the SPA way. If not, go ahead and reload the page. Let’s say you have the todo list app - if you haven’t used Asana, its layout is basically a left navigation column, a middle task list column, and a right details column. In the middle column, you can add, delete, and reorder the tasks. In the right column, you can comment, change description, etc.

                                                                                                              I’d make the left column just standard links. The right column would be a standard form. The middle column is a list of links and forms together. The links let you view details. The forms do move up, down, delete, and check off as completed. Those are the ones where you can do the progressive enhancement - make the checkbox, for example, ajax submit the form, and if success, leave it alone; the server now reflects what you see (the box is checked). If error, render that. Ditto on move up/down (which you might even do via drag and drop) - the ajax there is just bringing the server up-to-date on the client UI state.

                                                                                                              Notice that each individual form here would correspond to a single api call the SPA would use too.

                                                                                                              1. 1

                                                                                                                Got it! Thanks for clarifying :-)

                                                                                                        3. 1

                                                                                                          I think a better “decision tree” for SPA is this:

                                                                                                          Are you trying to pad your own resume with useless technology buzzwords that appeal to other buzzword obsessed Kool kids and technologically clueless recruiters? Then maybe an SPA is what you want.

                                                                                                          Are you trying to build a tool that solves a business need, is reliable and maintainable? An SPA is probably not what you want.

                                                                                                          1. 2

                                                                                                            Okay, now, this isn’t entirely fair–and I posted the submission a few days ago that originally talked about this.

                                                                                                            There are certain types of applications that aren’t just documents and that require a heavy degree of interactivity. Things in this category would be: spreadsheets, document editing or generation (think WYSIWYG or similar), certain types of advanced user interactions (click on realtime data, see a bunch of buttons pop up, pick one to change rendering or add/remove one or change styling), and arguably even some types of streaming events.

                                                                                                            If you find yourself building one of these applications, you simply aren’t going to get the responsiveness (or sanity) you want by continually banging up to the server and back.

                                                                                                            However, I’d say that 97% of web pages are not in this problem domain. Those pages would be better served as boring server-side pages, and would actually benefit from some of the things we take for granted developing that way.

                                                                                                            1. 2

                                                                                                              I’d say the genuine need for SPA is so rare it should be treated as an exception to the rule.

                                                                                                              Like: should you use eval() (or whatever your languages equivalent is)?

                                                                                                              The answer is “no, and if you have a genuine need for this you are the exception to the rule and should be able to talk at length about why you’re breaking the rule and why your approach is valid”

                                                                                                              1. 1

                                                                                                                And many interactive sites don’t need an SPA anyway. The traditional Todo list tracker is just simple interactivity, readily doable with a quick page reload

                                                                                                          1. 1

                                                                                                            Nobody pays extra to the government. Charities though are good causes.

                                                                                                            I’m most amazed at the workflow of multiple GitHub accounts. It just doesn’t seem to be the way GitHub is used.

                                                                                                            1. 1

                                                                                                              I keep my work and personal github accounts separate, via .ssh/config crapola. It works ok.

                                                                                                              1. 3

                                                                                                                I have one github account. I commit work on the office stuff using the laptop they gave me, with my author info corresponding to my work email. Personal email for git commits is configured on personal laptop.

                                                                                                                1. 2

                                                                                                                  I keep mine separate also, but it’s easy because my work account is only accessed from my work laptop, and the personal account only from my personal machines.

                                                                                                                  TBH, I’m surprised any companies even allow employees to use personal accounts for work.

                                                                                                                  1. 1

                                                                                                                    TBH, I’m surprised any companies even allow employees to use personal accounts for work.

                                                                                                                    Why is that? It’s probably no surprise that GitHub company policy is to have one account for personal and work purposes.

                                                                                                                    1. 4

                                                                                                                      I just view it like an email address. I wouldn’t use my work email to handle personal issues, and likewise I don’t use my work GitHub account to work on my personal projects.

                                                                                                                      It is a little different than email because I don’t think my work Github account is actually tied to my employer in any way, except that we follow a naming convention and sign up with our work email accounts.

                                                                                                                      1. 3

                                                                                                                        I see; that makes sense.

                                                                                                                        For me, my work is often public facing, and sometimes there’s no clear delineation between work and non-work – not in the unhealthy sense that I don’t know when I’m working and not, but in the sense that a given PR or commit may or may not be seen as falling under the aegis of “work” or “personal”; e.g. contributions made to an open-source project that isn’t owned by me or my company, but done in work time because I’m using that project in work. (Or contributions to an open-source project that is owned by my company, but done in personal time because I’m using that project at home. etc.)

                                                                                                                      2. 2

                                                                                                                        I’m more surprised when workers voluntarily disarm. Like, my personal life and my work life are separate, and it is important to maintain that separation, particularly when, like in many jurisdictions, there is a strong claim of ownership on the product of the worker, when not on company time.

                                                                                                                        1. 1

                                                                                                                          I think you might have gone off the deep end here. You’re suggesting I add a tonne of labour (multiple browser profiles to be logged in to multiple accounts, multiple git configs to author commits as each identity, multiple ssh configs to authenticate pushes under separate accounts) to enforce an arbitrary separation of identities, to what effect? My contract makes it clear that my own projects are my own, regardless of when I spend time on them.

                                                                                                                          This isn’t workers voluntarily disarming, it’s workers performing less labour to achieve the same outcome.

                                                                                                                          1. 1

                                                                                                                            I agree that would be annoying, but in my case, at least, there’s zero overhead because I only log into my work account from my work laptop, and then the personal account from my own machines.

                                                                                                                            1. 2

                                                                                                                              Fair enough! I only have the one.

                                                                                                                1. 5

                                                                                                                  A lot.

                                                                                                                  Finishing up contractual work for a very simple tool that’s gonna enable my client to not change his workflow at all, all the while accelerating their work and reducing their error rate by automating a rote boring repetitive task. I’m pretty proud of this one.

                                                                                                                  Also, it’s my eldest daughter’s birthday, so it’s everybody to their battlestations. Asides from that, it’s a “regular weekend”, meaning lotsa upkeep and chores, extracurricular activities, and maybe I squeeze in a few hours of gaming. Maybe.