jonstaab

Sounds like you might want to move on. I've been at kinda crappy startups for 4 years now, not being paid much and working hard. But like, Idaho hard. 55ish max hours a week. And I've stuck to it because I have so much agency. I live a very modest life, but work flexible hours from home, self-direct my work, make my own decisions. There are things I miss (e.g. working with other engineers), but the work is valuable, meaningful, and mine. I like it and from what people are saying in this thread I seem to have it made.

I understand it's not always simple to make the change (which is why I've kept my standard of living relatively low on purpose). But it can be done, there are places way out in the sticks that need good talent, and even if you're not architecting realtime distributed systems there can be interesting projects on tiny teams.

Just don't type while (true) {} or you have to throw everything away.

The quote is from Herodotus Book 9 Chapter 122, "Soft lands breed soft men", by Cyrus the Persian.

Reference: http://www.perseus.tufts.edu/hopper/text?doc=Perseus:text:19...

I was a little disappointed not to read anything about conscientious objectors, having just read Wendell Berry's 1987 article "Why I am NOT going to buy a computer" [0]. Idealistic as he is, Berry's work appeals very strongly to me. But maybe there isn't anyone like that anymore.

[0] http://home.btconnect.com/tipiglen/berrynot.html

Checks are turned off by default. Are there performance implications even when they're turned off?

Reference: https://clojure.org/guides/spec

I think that impulse is correct. As a clojure-lover, the state of error handling, and particularly Rich Hickey's decision to neglect it for so long and not code defensively, makes me a little sick.

That said, clojure remains my favorite language despite this flaw, and I can't wait to spend more time in it. It's beautifully designed. The design communicates well how to use it well, and it's only when you're abusing the language (or making mistakes) that you run into this kind of stuff. Not an excuse really, I'm just excited that errors are going to get somewhat taken care of by incorporating spec into the core.

It maps well enough that getting started is easier with a vim background, but it's different enough that I have a hard time using vim when I ssh into our servers, and I do the whole "ten keystrokes with caps lock on, oh no" except instead of caps lock I have kakoune muscle memory.

Sure:

Sublime was what I started with, and stuck with for 5 years; it was fast, pretty, familiar, and I cannot emphasize how much I love multi-cursor select (C-d). Also the overview bar on the right is brilliant.

Eventually I got frustrated with sublime's lack of customizability (I didn't dig deep, but the plugin api seemed lacking; VSCode seemed to be more plugin-oriented), and especially its lack of good macros; Sublime macros don't include things like fuzzy finding and find/replace, which made them very nearly useless to me. VSCode was basically just a better Sublime; but I only spent a few weeks with it so take my review of it with a grain of salt. Due to its lack of good macros, I quickly decided to look into vim/emacs.

I spent a couple weeks pitting them against each other, before going with vim. I originally was more excited about emacs because I like lisp, and it's infinitely scriptable. Both had great macros, but what eventually got me was two things:

First, the old comic[0] about learning curve is true, and after a week with vim (the third time around admittedly), I got to an "aha" moment and started being productive, while I got lost with emacs since it's so general-purpose, and its areas of application are so diffuse.

Second, the focus of vim on text editing rather than emacs' trying to get you to do everything in it jived with what I was after: a better text editor, not a better repl/browser/whatever. And the elegance (despite the cruft) of vim's terse dsl is just awesome. I like paradigms, and that is a good one. Also, as a side note, while VimScript is insane as a language, scripting vim to do common things was pretty ok; for more special purpose tasks I usually just recorded a good macro and mapped it to a command. Vim's macros are PEACHY KEEN.

I discovered kakoune just about a month after learning vim, but I had to wait a year to justify to myself ditching my new skillset for another one. Kakoune keeps all the good parts of vim (other than the large community), and improves on them.

First, it embraces the text-editing-dsl paradigm, which I find very compelling, improving on it by adding multiple selections (which I miss so bad from sublime), and always having at least one selection as part of their noun-first conventions (as opposed to vim's verb-first conventions). This results in some weird hurdles that I haven't figured out (after 2 months), but even with my inexperience, I'm much faster at editing code than I was in vim.

Second, it embraces the unix philosophy of doing one thing well; this was super annoying at first, but its solution was "use a tool that does that well, and glue them together with your own scripts". This was a big reason I took so long to adopt kakoune; I didn't have time to not only learn a new editing language, but also write my own damn editor. But when I eventually did, it was totally worth it (and way easier than I had feared).

For example, kakoune doesn't do window tiling. This forced me to start using tmux, which was really good for me; I got rid of my osx multiple desktops in favor of lots of tmux windows, and I now use the same hotkeys to manage my editor's panes as I do my terminal panes. I had the same experience with fuzzy-finding. I was mad at first that I had to implement my own, but after understanding some of kakoune's basic scripting paradigms, it was a 5-line script in my config file. So easy.

Also, what this means is that kakoune's plugin architecture is infinitely more powerful than Sublimes, VSCode's and even vim's, since it's as powerful as bash (I know you can shell out in vim, but only synchronously; kakoune supports async. Also, I know, NeoVim solves this too).

So there you go. Thanks for asking! YMMV with kakoune of course; I'm very much a text editor over IDE person; I work on a relatively small project most of the time, so intellisense etc is much less valuable to me than a snappy UX and the ability to customize my editor in whatever insane ways I decide (both ad-hoc via macros, and through tool integration), though of course I've heard of folks integrating intellisense into kakoune with very little effort.

I've heard people describe vim as beautiful in a Zelda: Link to the Past kind of way, which I think is true. Kakoune is beautiful in the same way, but without all the weird monsters lurking in the dungeons.

[0]: https://stackoverflow.com/questions/10942008/what-does-emacs...

I love this! Having moved from Sublime to VSCode to vim to kakoune over the last year, I'd love to do the same with my browser. Scripting it in lisp is just extra neat.

I can't use it as my primary browser yet, of course; since most of my time is doing web development I need my dev tools. Also, Slack won't even let me in, so there's that.

Having personally witnessed all of these symptoms of "agile" on teams I've been on, I was pleasantly surprised to discover when I read Jeff Sutherland's book that none of these problems have much to do with Scrum, which is more of a way of thinking about building (and tearing down) processes to optimize for the things only the team can identify, than a process itself.

I think the reason these sorts of bad practices crop up so often is because internalizing and applying the sort of ego-free principles of Scrum is very very hard, even for a small team (or individual).

Reading that book [0] (particularly the first half) was eye-opening for me, and I recommend it to anyone who works in an "agile" environment.

[0] https://www.amazon.com/Scrum-Doing-Twice-Work-Half/dp/038534...

Edit: I would add that the linked article is pretty typical of things I had read online about Scrum before I read Jeff's book, and I believe are very misleading and unhelpful, as they abuse one way to solve the problems they complain about. Bad team dynamics didn't come from Scrum. Maybe Scrum failed, but that's a whole different discussion.

Yep, the printing service is a third-party api (PrintNode) that routes the request to one of any number of desktop clients.

The reason we did it this way is 1. we have a web app so we can't print directly to their printer without a print dialog, and 2. we want to print to potentially a different device than the user is on.

Here's[0] a game I wrote a while back to learn Elm; it's a mashup of Tetris and Boggle. It's web, but I _think_ it should run on OSX (use full-screen for the best experience).

[0] https://jstaab.itch.io/tetroggle

Edit: linked to the actual game

1. Client creates a custom label and we store it in s3 2. They select x inventory items + click print 3. We retrieve and send the label file + inventory data to a service that interpolates the data into each template, renders to pdf, merges them, and forwards it to our printing service.

We certainly could do the work on the client, but they're making this request in a context where neither the label nor the libraries need to be loaded; in fact, in our server-side implementation, it could be done with a single api call. Doing it all client side would strongly couple the client to the technology.

Also, we re-used this api in two applications, one of which never loaded the editor (along with its dependencies).

TLDR; a weird hack was better than violating separation of conerns.

I would have loved to, but one of the sticking points was that the label file had to be serialized, saved, and later interpolated with data from a bunch of different records, which is why I used svg over canvas, wrote my own editor, etc. jsPDF seems great for imperatively generating a pdf, but not for editing/loading template files. Plus, since the pdf generation had to happen server side, I would have needed a headless browser anyway.

It's super weird, and I've been over it from every direction but I don't know how I could have done it differently.

Just recently I had to put together a web-based UI for editing vector graphics (clothing tags) and export them to pdf for printing. In order to avoid writing and maintaining two separate codebases, I re-used the client side code as my rendering code.

So I ended up with a server serving the editor frontend, as well as api endpoints that would use puppeteer and headless chrome to make a request (to itself) to load the frontend, import a given label file, render it, take a screenshot and save it to a file, then reply to the api request with the contents. So kind of a recursive api.

I had so much fun with this but I still can't believe I had to write my own svg editor and bake my own pdf generation and merging code to get the job done. It should not require two languages (node and python) and a headless browser to get the job done.

I've been wondering for a while about the practicalities of using postgres as a replacement or near-replacement for a traditional backend - does anyone have any opinions on how far it's wise to go with this (postgres-only? authentication? direct connections from the client?) and/or how feasible that kind of thing is?

For anyone interested in a really good biography on Tesla, this [0] is the best one I've read. It's written by John J. O'Neill, a journalist who knew Tesla personally for 30 years or so IIRC. It sticks to the facts, eschewing the various myths about aliens and such that tend to stick to him, and it covers his whole life, from what is known of his childhood all the way through his death. It's a super interesting read.

[0] https://www.amazon.com/Prodigal-Genius-Life-Nikola-Tesla-ebo...

Gah. It was up 3 minutes ago. Anyone have any suspicion this is another ddos episode? I saw that SO was down last night too: https://twitter.com/StackStatus/status/836450836322516992

http://downdetector.com/status/aws-amazon-web-services looks like a reasonable alternative place to check/report downtime.

Some friends of mine started a wordpress company a few years ago, and after some thrashing trying to find product/market fit, they ended up pursuing real estate SEO, MLS indexing, and easy wordpress + mobile app generation. Check out https://wovax.com/

It polls. If too many people join we'll end up DDoSing github again

ooops

Thanks! OS is the bomb

That's super interesting; I didn't know git was so inconsistent across platforms. Valuable knowledge. I'll add that in.

I'm sure someone's going to eventually hijack the account. I'm not too worried about it. 0Auth would've been a good idea though.

Ah good call. I'll add the install bit in there.

The repo is here:

https://github.com/git-chat-client/git-chat-messages

Also, I don't have OSX, so I'm not sure how to test that. Probably something with your git configuration or maybe my naive parsing of the logs?

Really, only the last paragraph of that post are relevant here. Secular materialism and Christianits share reason in common. The difference between the two is their explanation of why it works, where it came from, and why it matters. That's where circularity starts to happen.

All worldviews start with assumptions. Secular materialism relies on circular arguments as much as Christianity, they just explain less (see Orthodoxy by G.K. Chesterton). The only difference is that materialists often refuse to admit their assumptions - which is why, as a Christian, I admire nihilists - they're not afraid to admit their axioms and follow them to their logical conclusions.

While what you say is true to some extent for Western Christianity, the fact remains that Christianity has taken deep root in a number of places in the world that were free of western biases, e.g., China, Korea, Africa, and South America. A huge diversity of cultures have had their own struggles with Christianity.

Another question for another day. Off the top of my head I can't think of a reason they wouldn't be able to create some form of objective meaning. My problem with lies more in the problems of evil, ontology, epistemology, and a compelling narrative to history.