throwawaylala1

looks like they're crypto guys

so there's that

Any time something is adopted as broadly as JavaScript it's going to be a mess. Even outside the world of computing. Take... city planning. Cities are a mess. In fact human civilization is one big freakin' mess.

Wouldn't it be nice if we could start over and apply all the lessons we've learned over the generations? The world would be a much better place!

Or would it?

We'd end up with yet another mess. It'll be a different mess but it'll be a mess nonetheless. Or worse - we'll end up with two big messes instead of one big mess!

Also, since you’re probably deploying containers to production, it’s useful to have a similar environment for local development so that you know what will actually happen in production.

This such a complete and utter lie and I'm surprised people in 2022 still believe it.

You do know what's happening when you run Docker on your Macbook, right? Right?

I mean it's a pretty simple concept.

Your frontend team needs an API call that retrieves only friend requests with user names/avatars because the current API call is too heavy.

Normally they'd go to the back-end team and ask them to add an endpoint or modify an existing endpoint to give them the exact data they need. The problem with that is global API surface area becomes more complicated. Complexity is bad because more mistakes are made.

With this model your front-end team can implement the endpoint themselves in the BFF and model the response data exactly as they need it.

They also don't need to deal with that one zealot on the back-end team that gives everyone a hard time about tiny irrelevant issues.

You can turn off recommendations

Not really. When you turn off recommendations, the app icons are hidden but the space for recommendations stays there! Yes, just a big ol' block of whitespace with a prompt to turn recommendations back on. It takes up like 30%+ of the start menu.

It's a dark pattern.

Wow Snowflake absolutely crushes these benchmarks. Anyone know why? I don't know much about this space.

Wouldn't you lose more just by sitting on cash? Even now?

Right, I was just pointing out the flaw in the parent commenter's statement. You can't do "code version is tied to your database version" - that's just not a thing.

You can't restart all of your web services atomically. What happens if two web services are running two different versions for a couple seconds?

More practically

event sourced architecture

You must be joking. Please tell me you're joking.

I use VIM and didn't even know ACME editor existed.

Keep building strawmen, I'll be building software.

Which didn't answer my question at all. Adding more structure to the AST with @param/@return/whatever doesn't make for better documentation. It's useless crap in a real world scenario.

I have. My editor also gives me documentation for every function that I need. Plain text is more than enough for that use.

What kind of function documentation are you reading inline lol? Does it have like 30 function arguments?

So here's an example of the string package: https://pkg.go.dev/strings

In what way would the JavaDoc @param/@return/etc annotations actually help? What Godoc has is more than suitable for the vast majority of cases.

This is why I said it's hard to succinctly explain. Non-programmers and bad programmers can't tell the difference between Go and Python (for example) in this context. The actual difference is very very significant.

Single Point of Failure. LOL.

You may be right, but... and maybe I'm being naive here... if HN can do it, why can't local social networks? The amount of people in the network is even smaller than HN. I suppose the problem is finding good moderators that keep to an ethical standard and that ethical standard is different everywhere. Well I think I answered my own question lol

The best way would be exporting docs from your codebase, and have all documentation related artifacts expressed alongside the code

I LOVE Golang's approach to this [1]:

- Documentation generation from code is built in to the language toolkit

- There is a standard for writing the comments so all of them look the same across every project

- It even supports code examples which are visible as a REPL in the generated docs

When people ask "what's so great about Go?". It's stuff like that which is hard to succinctly describe but makes a huge difference in overall quality of Go code in the wild.

[1] https://go.dev/doc/comment

We have one too but it's overrun by jerks. Lots of bickering and ganging up on people.

Sure. We could also not use a container registry. Or resource management. Or liveness/readiness probes. For the database we could use RDS and take the latency/$$$ overhead. For file storage set up a separate EBS volume or whatever. But... why?

This is a tough one.

I wouldn't worry that much about employability. If you're honest, hardworking, and love writing software then I don't see any issues there. I'm sure you've solved enough hard interesting problems that'll carry over to other industries. It's all about moving bits anyway. You'll even have a leg up if you have a better than average understanding of security.

You may be holding yourself back because it does take some time to ramp up in a new "vertical" (so to speak). Building new professional connections, etc. So like... maybe in an alternate universe you'd be working your way up the ladder at Apple or Google or whatever. That time invested does pay off and there's an opportunity cost there.

The tough one is the ethical question. Sometimes it's hard to tell if our disillusionment is internal or external. In other words, is it nagging you because you can see why the public is negative towards crypto or is it nagging you because you don't want to alienate yourself from the crowd?

If it helps, I've long held the strong belief that I should wake up in the morning guilt-free about my job. I need to feel excited about coming in to work and tackling the next big problem. I refuse to work for or with jerks. I refuse to work on products that aren't striving to make things better. I refuse to work on exploitative or manipulative products. I refuse to work for unfairly low pay. And all of that positive energy (great product, great people, great mission, good/great pay) make the dark/hard times easier to manage.

In the long run I feel like this philosophy has made me a happier and more successful engineer.

EDIT: Just to give you an idea of how I applied the above philosophy. I once quit a well paying job in the very first month because a senior engineer was an insanely venomous person and no one seemed interested in stopping them. I didn't make a big stink about it, just quietly moved on. The next job I found was amazing and I'm so glad that I did what I did. Yes it was scary.

I'd rather not say but it wasn't anything mind blowing. It was a B2B thing with a great UI in the early 2010s. You'd never have even heard of us. All of this predated the popularity of k8s. Docker wasn't really a thing. AWS was just growing and blowing everyone's minds.

Yea. We had a monorepo. The whole thing was one big webapp.

Even our background workers ran in the web app. Oh yea, that's right. I can feel the cringing just writing that! So like if we had an expensive background operation, our web app would start up a thread and do the work. Some might be wondering: "What if you needed to restart it? Like, I dunno... when deploying code?". Answer: we didn't, lol. Our deploy script would hold all new jobs and wait until existing ones finished before restarting. Some background process were extremely time consuming (eg: 10+ hours) and those we wrote in a way that they could just resume if killed.

It's actually amazing how productive you can be with a single monolithic web app on a beefy cloud instance.

I was also surprised how quickly we were able to scale out to a proper multi-service architecture after being bought. It only took us 6 months. The big company that bought us plans ahead years. It was no problem at all.

Now don't get me wrong. I'm not advocating for sloppy engineering here. Our team was some of the smartest people I've ever worked with. It wasn't uncommon for me (a medium-experienced engineer) to bring a proposal to our technical founder that would require like 1 month of work. That freakin' genius would reframe the problem and architecture such that we'd spend 2 days, still achieve the same goal, and take on minimal technical debt. I learned A LOT.

I know I'm rambling, but honestly I don't know if that kind of hustle is even a thing anymore. Are tech startups still scrappy? Are they focusing on the core problems/solutions they're trying to prove out instead of layers of architecture? Do such problems even exist anymore? Back in the mid-2000s it felt like that's how everyone did it.

If you're truly interested in being enlightened then do the work. It's not up to internet strangers to refute your painfully uninformed assertions in detail. That's what education and work experience are for. You simply can't cover it in a comment.

I wrote my comment to make it clear for anyone else who doesn't work in this area that what you said is utterly wrong. HN typically has well informed comments so people take it a little more seriously than other places. The thread is also old enough now that no one except you will probably read it.

I'll at least give you something so that you're not left holding nothing but a mean internet comment.

First: If you were to rank the hardest technical challenges in modern computing then UI architecture is easily in the top 5, if not #1. In that same list you have distributed (as in networks) computing. It's an incredibly difficult problem with an endless pit of depth. UI IS HARD. If your next question is "what makes UI hard?" then - good! - you're curious. Take some courses or something. Try building a great UI for non trivial use cases. Educate yourself by doing!

Second: A computer drawing "hundreds of of complex 3d objects 120 times a second" has absolutely nothing to do with complexity of UI. The challenges in UI are not strictly a matter of drawing dots on the screen! The two things are orthogonal! Game engine renderers are solving a very constrained problem whereas UI architecture is totally unconstrained.

Third: Game GUIs have a TINY fraction of the UI components you'd need to support a sophisticated modern day business application (think Salesforce). Someone else mentioned accessibility but that's just the tip of the iceberg. The sheer number of UI components in business applications dwarfs what you see in games. Not only that but the UI components I'm talking about need to be assembled in an uncountable number of ways. And they're constantly being updated/tweaked.

-

There are many people who have devoted their entire life to finding a general purpose way to build great UI. No one has cracked it yet and it's not because people are stupid or don't want to. It's HARD. But also a lot of fun if it's something you enjoy doing.

I've worked at 3 organizations that adopted k8s. This all happened over quite a long period so I saw what k8s adoption looked like at varying stages of k8s development.

k8s gets shit for one very simple reason: it forces teams to deal with issues that they're not necessarily ready to deal with just yet. I've seen it happen over and over and over.

Small startups are able to get away with not using auto-scaling, having bad secret management, not running minimally sized containers, etc, etc. Are they going to solve these problems eventually? Yes, if they grow and don't die. But until they grow they simply can't afford dedicating a lot of effort setting up Hashicorp Vault with proper secret rotation (just as an example).

One of the companies I worked at was a 10 person startup that was trying to find product market fit at a break-neck pace. We had customers, big ones. It was a non-trivial piece of software too. We ran the whole thing on a very beefy EC2 instance. The DB and the application were on the same server. Provisioning an application server was all done with a single bash script. One time we had to re-provision this server and we had take everything down for like 3 hours. We did at 3am so none of our customers got disrupted.

Every single ounce of engineering time was devoted to product development. We ended up getting bought and everyone (all 10 of us; founders were generous and awesome) made a crap ton of money. I can tell you with absolute certainty that every major feature we shipped contributed to that acquisition. Had we dedicated any effort at all to proper infra it just wouldn't have happened. The cost of our crappy duck taped infra was that one night we needed to reprovision everything and maybe another 20 total hours of wasted time across all engineers in the company.

That's why the first line in the blog post specifically cites early stage startups.

The miscommunication is in your mind.

Every software out there has defects. Bugs, performance issues, UX issues, etc. To assume that anyone in this thread actually means that submodules have no defects whatsoever... well... that's just creating a straw man to tear down because you're grumpy or something.

The issue appears to be with your understanding of what "bad" means in this context. When the OP (and commenter I was responding to) says "bad", they're referring to the overall experience of using git submodules. That specifically does not include the minor fixes/improvements you'd find in a changelog.

By your definition, all software is "bad" because all software has defects in varying degrees. That of course makes the entire conversation pointless and pedantic.

Git submodules work just fine when they're used properly. I've been using them for years without issue and so have many other commenters here. Are there things we (the users of git submodules) would like to see improved? Of course! But that doesn't violate the statement that there is "nothing bad" about submodules in the context of this discussion.

I really hope this helps you navigate conversations with a little more nuance. If not, that's okay too. Have a nice weekend.

You were elaborating on the comment, weren't you? And that comment was quite vague too.

What was vague about that comment?

The difference between "what are uses and misuses" and "what is good and bad" is not enormous.

This is incorrect. The definition of "bad" is something of low quality. Misusing a tool and then calling it low quality is dumb.

Plus, there are things that are flat-out bad. It's a human-made program under constant development, after all.

What about git submodules is "flat-out bad"?

It's ironic that you're criticizing others' comments on being vague and providing non-answers while you've contributed nothing to the discussion. Maybe educate yourself on technical things and you won't need to waste your time having meta discussions on internet forums. Looks to me like you want to contribute but have nothing of value to say.

It was a response to a comment, not the OP.

There is nothing "bad" about submodules. They do what they were intended to do very well. They are often misused because people don't take the time to understand how things work (event at a conceptual level) before diving into it.

I've found submodules most useful when I'm tracking an external dependency that doesn't change often -and- I don't have a dependency management system to lean on.

For example, I have a repository of 100+ various bash utility scripts. One of the scripts depends on another repository with 500MB of data. I don't use it often so I don't need that large repo cloned alongside my bash scripts every time. In this case:

1) The dependency doesn't change often and I like being deliberate when using a new version of that dependency.

2) The dependency is optional and can simply be ignored when using Git's default clone behavior for my repo.

3) Since it's just a bunch of bash scripts, I don't have a package management system to lean on. I use these scripts on multiple *nix distributions.

Could I make it work without Git submodules? Yes. I would have added the dependency to .gitignore and wrote a script to `git clone` the dependency and set it to a specific revision. Submodules just makes that process a lot easier.

Exactly! Submodules are a tool within a toolkit. Learn the toolkit, learn the tool, and then decide whether or not it'll solve your problem.

Whenever I talk to video game programmers, they scoff at the idea that UI is a difficult problem to solve. And they're right.

You have no idea what you're talking about.