News for hackers. Stuff that matters.
Re:XML Is the Future by gnulinux on Sunday June 25, 2023 @03:09PM (#36471561)
I've been working in the tech industry in the US for about 5 years. Ever since I knew myself I've been coding. From middle school to high school, given any problem, like Sudoku, or keeping up daily chores, my solution was Programming! Programming wasy homebase. Then I studied it in uni, thought I was kinda good at it, and loved it.

But when I started working in the industry, I realized that it's absolutely exhausting. Hype after hype, fad after fad, modern after modern, refactor after refactor. I have a workflow, I know how to build apps. Then one day director of Ops comes and completely and utterly changes the workflow. Ok fine, I'm young, will learn this. Month passes, it is now Terraform. Ok fine I'm young, will learn this. Now we're serverless. Ok fine, will learn. Now everything is container. Ok. Now everything microservice. K. Now turns out lambdas aren't good, so everything is ECS. OK will rewrite everything...

Look I'm not even complaining. But it feels like I'm stuck in a Franz Kafka novel. We just keep changing and changing the same things again and again because that's the new way to do. Big distraction. Destroys your workflow. Forget about all the util scripts you wrote last 6 months being useless.

I don't even know how I would do it. Maybe I would do this the same way if I had any power. But that doesn't change the fact that it's a bit ridiculous. Fun but tiring. Entertaining but exhausting. Cute but frustrating.

Re:XML Is the Future by ArunRaja on Sunday June 25, 2023 @03:25PM (#36471711)
There should be tech threshold to adopt new technology. Chasing the fad is endlessly tiring and costly.
Re:XML Is the Future by lastyearmodel on Sunday June 25, 2023 @08:16PM (#36474097)
Completely anecdotally, but the most productive I've ever been in a company has been was a company in 2016-2019 who was on a monolith .ENT Framework with no kube/container setup at all.

Sure, it felt like absolute chaos some days, but I"ve never felt more productive and in a flow as then, mainly because we weren't chasing the latest and greatest thing but focusing on what's working for us and perfecting it.

Re:XML Is the Future by rqtwteye on Monday June 26, 2023 @12:07AM (#36475640)
The sad thing is that in many cases working on such a system is a career killer. Nobody wants to hire you. Some years ago a colleague and I realized that our company wouldn’t hire us judging from the job descriptions because we worked on systems that had been working for years but weren’t shiny. Since then I always something new to every project. Not because it makes sense but because it’s good for the resume. Other groups are even worse. Three devs writing 13 micro services on Kubernetes for maybe a thousand users ever.
Re:XML Is the Future by noduerme on Monday June 26, 2023 @12:28AM (#36475724)
After 20+ years of maintaining what amount to monoliths and services, I wonder whether I'd be hirable if I had to find a job at some big tech company. But I think the problem-solving ability you need to manage server clusters you built yourself translates into the ability to handle whatever their cloud junk looks like. Hopefully I'm never in that position, though, because I would absolutely hate a job like that.
Re:XML Is the Future by deaddodo on Monday June 26, 2023 @01:17AM (#36475986)
It's not a career killer, it's a specialization. Focusing on nodeJS JS/TS frontend+backend stacks will equally disqualify you from .NET/Spring shops (against an equally qualified applicant, at least). The same goes for making the switch to gamedev or systems dev from many years webdev (you can do it, but you'll probably be dropping back down to a Jr or Mid-level IC position), going from COBOL/Erlang/Rust to another stack, doing Salesforce (or other CRM/specialty software) development, etc.

It's going to happen to anyone after 10-15years in the industry.

Re:XML Is the Future by laeri on Monday June 26, 2023 @03:15AM (#36476675)
You are right that this is specialization but it still is a career killer in the case that you specialize on a completely obscure technology which will not help in your future career.
Re:XML Is the Future by plorkyeran on Monday June 26, 2023 @01:17AM (#36475989)
I think this fear is not entirely wrong, but is significantly overblown. There's a significant gap between what job descriptions ask for and what companies will actually hire. A resume full of dead technology isn't going to help you ladder your way up to bigger and higher-paying roles, but it's also not going to make you unemployable.

A resume full of less-shiny but still relevant technologies, otoh, has a lot of potential. You have fewer places to look for jobs, but you're a lot more exciting to the places which do want your skills.

Re:XML Is the Future by eschneider on Monday June 26, 2023 @08:21AM (#36478771)
When I look for a new position, I try and make sure it’ll allow me to learn a new fundamental skill rather than the latest new framework (though often there’s overlap:)

Over 30 years that’s allowed me to be employable across a lot of different tech stacks.

Re:XML Is the Future by lastyearmodel on Monday June 26, 2023 @01:57AM (#36476198)
I can only talk from my limited experience. The company I mentioned was my first workplace outside of university, and since then more than doubled my salary. So I don't think of it as a career killer, but instead a stable environment to get yourself skilled up in what it's _actually_ like in a dev role.
Re:XML Is the Future by hardwaresofton on Monday June 26, 2023 @12:19AM (#36475693)
> Look I'm not even complaining. But it feels like I'm stuck in a Franz Kafka novel. We just keep changing and changing the same things again and again because that's the new way to do. Big distraction. Destroys your workflow. Forget about all the util scripts you wrote last 6 months being useless.

Here's how I stay sane -- I focus on the changes. For the technologies that you noted, here are some good questions that come to mind to set them in my brain:

- What's the difference between CGI scripts and Serverless?

- What's the difference between Terraform and Ansible?

- What's the difference between a Bash script and a Makefile ? Is one more general than the other? Does one have a considerably better interface than the other?

All the solutions look the same, but the distinctions between them (even at a relatively surface level) are what help to actually tell things apart and stop the feeling of endless churn.

I think of it this way -- unlike other fields because the fruits of our research are immediately usable and almost zero-cost, we're given a front seat to the frontier of experimentation. It's a water hose, and you have to determine which streams are worth turning on/off, bottling for later.

Re:XML Is the Future by noduerme on Monday June 26, 2023 @12:38AM (#36475779)
I have this impulse to constantly experiment with everything too. And I think it's healthy for your brain to always be learning new ways and testing your preconceived notions of how you do things. A lot of times it leads to incremental advances, either in the next iteration of my existing code or the way I approach my next project.

But a lot of it, I can admit, boils down to sheep shaving. When you start figuring out how you'd implement codebase 2009 in stack 2023, and then actually doing it, that's golf. It's all good, it's educational, but it's downright immoral to sell that to a client and drag them through it.

Re:XML Is the Future by hardwaresofton on Monday June 26, 2023 @12:47AM (#36475826)
> But a lot of it, I can admit, boils down to sheep shaving.

AKA Yak shaving[0], which I am... unashamedly fond of doing

>> There are yaks to shave all over the stack, and I go where the yaks are. (quote is from my github readme)

> When you start figuring out how you'd implement codebase 2009 in stack 2023, and then actually doing it, that's golf. It's all good, it's educational, but it's downright immoral to sell that to a client and drag them through it.

I definitely agree that selling this to a client when you've told them you'll do the minimum to update the codebase is immoral, but if there is value in updating, then you should expose them that value.

For example -- moving a client to AWS might not make sense, but if they're maintaining on-prem infra and paying tons of money for an application that would actually cost less as a single ECS service (or App Runner, these days)... Then maybe you should upgrade their stack a little bit.

In the end it's your job as a consultant or an employee (if you're high level enough) to introduce change that will make the company better, if you see an opportunity.

Tech stacks crumble underneath their own weight, and if they're bad enough, become business risks. If it's humming along, easy to maintain, and isn't riddled with security holes, then great!

[0]: https://en.wikipedia.org/wiki/Yak_shaving

Re:XML Is the Future by noduerme on Monday June 26, 2023 @01:58AM (#36476205)
My idea of a major overhaul for a client is upgrading from Mysql 5.7 to 8 with no downtime and then slowly, over a year, finding queries that could be sped up with lateral subqueries or window functions. That's about the pace, and it's effective at keeping resource use in check. The wilder things I experiment with on the side are once in awhile actually useful for a new app or service...

I basically agree with you, if the cost of building the code will be easily outweighed by the savings to the client and I also think the platform will hold them for the next 10 years, I'll pitch it [e.g. I've moved many early clients from my servers over to AWS services when it made sense, and still maintain them]. But it's easy to see too how if I were trying to constantly drum up more work, it would be seductive to pitch them on new hyped up technologies they don't need, just to remain relevant and keep the checks flowing. I think that's the animating force behind all of this platform churn, not excited developers who just want to sheep or yak-shave (thanks. I always forget which ruminant I'm shaving ;)

Re:XML Is the Future by re-thc on Monday June 26, 2023 @01:09AM (#36475941)
> - What's the difference between CGI scripts and Serverless?

> - What's the difference between Terraform and Ansible?

Marketing and VCs

Re:XML Is the Future by andrewflnr on Monday June 26, 2023 @01:37AM (#36476078)
I would phrase almost the same idea from the opposite angle: focus on the fundamentals that never change, and view the trends in terms of how they relate to those fundamentals.

But also, those are some pretty odd comparisons. For sure Ansible and Terraform aren't directly comparable. If anything they're complementary. Terraform provisions machines (and also infra, etc), and Ansible configures provisioned machines.

Re:XML Is the Future by hardwaresofton on Monday June 26, 2023 @01:59AM (#36476215)
> I would phrase almost the same idea from the opposite angle: focus on the fundamentals that never change, and view the trends in terms of how they relate to those fundamentals.

Definitely -- I'd say that these questions force the understanding of the fundamentals, because that's what you get down to ("fundamental"/irreconcilable differences).

The problem is that fundamentals can be similar, and sometimes the difference is elsewhere (UX/DX/perf for example).

> But also, those are some pretty odd comparisons.

So they are odd comparisons, in some sense -- but the point was to reflect the kind of questions someone who didn't know the answer would ask. Ansible and Terraform (and Salt/Puppet/Chef) are often presented in similar context and they're often confusing precisely because they are so close but different.

The other example (CGI vs Serverless) is situation that's somewhat more targeted towards the age discussion -- did we churn over the years for churnings' sake?

> For sure Ansible and Terraform aren't directly comparable. If anything they're complementary. Terraform provisions machines (and also infra, etc), and Ansible configures provisioned machines.

What you've said is the usual rebuttal (and it's mostly right!), but did you know that Ansible did/does provisioning?[0] The lines aren't drawn as neatly as they seem to be.

You can build a Terraform-like experience out of Ansible, if you wanted to, and it's important to know that and why you choose a tool like Terraform instead of traveling deep into Ansible land.

All that said, if you prefer, replace "Ansible" with "Pulumi" (Full Disclosure: I'm firmly on the Pulumi side in the Terraform vs Pulumi debate).

[0]: https://docs.ansible.com/ansible/latest/collections/index_mo...

Re:XML Is the Future by 28304283409234 on Monday June 26, 2023 @03:30AM (#36476776)
A better comparison would perhaps be “ansible” vs “puppet” vs “chef”.

I wrote everything in shell, then puppet, then chef, then ansible. Doing literally the same thing. Because fads.

Re:XML Is the Future by hardwaresofton on Monday June 26, 2023 @04:43AM (#36477273)
Taking this comment in good faith, because HN...

Do you really not see any difference between Ansible and a shell script?

Even just the move between shell and bash/csh/tcsh/zsh whatever else can make a marked difference in productivity and ergonomics.

Re:XML Is the Future by TeMPOraL on Monday June 26, 2023 @05:13AM (#36477469)
> Do you really not see any difference between Ansible and a shell script?

Surely they do, but how much those differences matter depends on where those tools sit in relation to what you're trying to achieve.

For example, I could write essays about the differences between bash and PowerShell, and about differences in productivity their various facets create, in both abstract and concrete terms. However, when my task is not about shell scripting per se, and the script plays only a minor role in the solution ("oh, but we can make the button launch a script that launches X"), and my main concern about that stage is to convince the team to use Bash and/or PWSH instead of making Python a dependency in the project - then bash and PWSH are really the same thing to me - any difference in productivity for that use case is dominated by one's familiarity with the tool, and none of it matters anyway if my co-worker succeeds slotting in Python for that use case.

Similarly, there are many differences between bare shell scripts and Ansible, and there are differences between Ansible and Puppet and Chef too. But they're also close to each other, so if your use case doesn't hinge on those differences, you can be excused for wondering why can't we just keep using a Makefile for this.

Re:XML Is the Future by allarm on Monday June 26, 2023 @05:23AM (#36477529)
I mean, yeah? Ansible has roles, collections and a great inventory system. There's a lot of extra steps if you want to use a shell script instead, to i.e. install Docker on multiple hosts running different OS versions. I don't really like Ansible, but I think it's quite good for provisioning. It's also super easy to write filters and plugins for extra functionality.
Re:XML Is the Future by WesolyKubeczek on Monday June 26, 2023 @10:31AM (#36480084)
I can see that Ansible with its do-it-yourself-AST-in-YAML is more tedious to write and even debug :-P No wonder they have shorthand versions of their module calls, too.

I'm still using it, though every piece of software lately, fad or not, is something I tend to endure or survive or cope with, rather than use or enjoy using. Little papercuts everywhere.

Re:XML Is the Future by 28304283409234 on Tuesday June 27, 2023 @02:31AM (#36489566)
Context: I wrote deploy and configurations in Shell in 1999, for Employer A. I started writing Ansible in 2013, for Employer F.

In the middle I wrote puppet and chef. All doing basically the same stuff. And yes, obviously there's worlds of differences. Using Puppet killed my productivity, for example.

But my point was that those tools are more comparible than 'terraform' vs 'ansible'. I stand by that comment.

Re:XML Is the Future by hardwaresofton on Tuesday June 27, 2023 @03:02AM (#36489752)
thanks for responding -- I do agree that ansible, puppet, and salt are the closer comparisons (they are of the same lineage -- I mentioned them in passing and kind of clumped them together).

See my response here[0] as well, but to summarize:

- There is more overlap than it seems on the surface (not implying that you are taking a surface view)

- I wanted to get across was the way someone might ask if they were new/looked at it all as churn from the outside. The average dev who thinks "devops churns too fast" is not necessarily going to know the difference between ansible and terraform to begin with, never mind knowing that ansible/salt/puppet/chef are a different approach/lineage compared to terraform.

> And yes, obviously there's worlds of differences. Using Puppet killed my productivity, for example.

I never used Puppet -- it was love at first sight with Ansible for me, felt like the perfect amount of abstraction/structure even though some of the patterns were long in the tooth.

My career is not as long as yours, but I still use ansible to this day (with pulumi).

[0]: https://news.ycombinator.com/item?id=36476215

Re:XML Is the Future by sofixa on Monday June 26, 2023 @08:42AM (#36478971)
> What you've said is the usual rebuttal (and it's mostly right!), but did you know that Ansible did/does provisioning?[0] The lines aren't drawn as neatly as they seem to be.

In the same way that a toaster can be used as a hammer if you hit nails hard enough with it from the "correct" side. Ansible barely does it's main purpose, configuration management, but abusing it for provisioning is just on a different level. Even overlooking the extremely narrow feature set, just `state: absent` should be enough to convince anyone Ansible just isn't made for provisioning. Add it the bolted on templating of a configuration language that uses spaces for logic, the fun of Python dependencies of which you need a ton to do any provisioning, and you're just in for a massive world of pain for literally no reason.

Disclaimer: I work at HashiCorp, but not on or with Terraform, and have had a disdain for using YAML for anything other than basic configuration and Ansible for anything other than simple, basic, low complexity and low scale Configuration Management since I inherited an Ansible project to manage VMware configuration in a past job.

Re:XML Is the Future by kitd on Monday June 26, 2023 @02:44AM (#36476496)
Lord, teach me to accept the things I cannot change,

And use version control for the things I can ...

Re:XML Is the Future by coldtea on Monday June 26, 2023 @03:52AM (#36476920)
>Terraform provisions machines (and also infra, etc), and Ansible configures provisioned machines.

Each of such tools expands to take the role of the other (and also read email)...

Re:XML Is the Future by CraigJPerry on Monday June 26, 2023 @04:04AM (#36477011)
Hmmm i feel like those tools naturally railroad you into a certain split of responsibilities.

Sure - you could use tf’s local/remote-exec to do the stuff you’d normally do with ansible but man that would be annoying and slow going when you know you can reach for ansible.

Vice versa, you could have an ansible playbook to call the cloud provider’s api and cook up some kind of approval workflow / state management but man that would be annoying and slow going when you know you can reach for terraform.

Re:XML Is the Future by TeMPOraL on Monday June 26, 2023 @04:28AM (#36477172)
Do they integrate that well? I don't have much experience with either, and until this moment I understood them to be substitutes - but still, I thought that:

> you could have an ansible playbook to call the cloud provider’s api and cook up some kind of approval workflow / state management

Was generally what people did before Terraform, and they be reluctant to add another complex tool, significantly overlapping with the current complex tool, just to simplify a part that already works OK.

Conversely, if Terraform is really so amazing as one would believe reading HN, then some amount of "local/remoe-exec" pain seems justified if it lets you avoid bringing in Ansible with all its complexity?

All these tools cost not just storage and processing, but also brain space. A Makefile in a cron, running some shell scripts, may be more brittle than whatever cookbooks or playbooks or ${what's the name for Terraform's flavor of makefiles}, but is also might be easier to fix when something breaks.

Re:XML Is the Future by xorcist on Monday June 26, 2023 @07:34AM (#36478357)
> Terraform provisions machines (and also infra, etc), and Ansible configures provisioned machines

Ansible can provision virtual machines as well, and from my experience it is better suited for it too, since it doesn't save state outside the system. So there's lesser chance for it to get out of sync.

It's mostly culture. People these days learn GKE or Kubernetes first, and their tutorials mention Terraform so that's what they'll use. It used to be managed VMs and that culture was around Puppet, Ansible or Salt.

Re:XML Is the Future by sofixa on Monday June 26, 2023 @08:43AM (#36478987)
> Ansible can provision virtual machines as well, and from my experience it is better suited for it too, since it doesn't save state outside the system. So there's lesser chance for it to get out of sync.

State serves a purposes, it's not just there for fun. Ansible will lose track of your VM if you rename it (and can barely handle you renaming it with itself), and won't delete it if you just delete it from the configuration file.

Re:XML Is the Future by xorcist on Monday June 26, 2023 @01:32PM (#36482938)
> State serves a purposes, it's not just there for fun

The system has state. The question is how we want to manage it. The design in this case chooses to opimize to lessen the impact of errors. All real world systems are prone to errors in the long run.

If real world parables are excused: If the map (serialized state) and terrain (system state) differs, is it a good idea to insist on following the map?

> Ansible will lose track of your VM if you rename it

Sure, but so will Terraform. Or worse.

> won't delete it if you just delete it from the configuration

Sure it can. There are no limitations there. The only questions are whether you want it to, and how you want it to.

Ansible is a superset of Terraform. It's mostly a matter of culture which tool people choose, and which you think is the easiest to use.

Re:XML Is the Future by sofixa on Monday June 26, 2023 @01:50PM (#36483198)
> If the map (serialized state) and terrain (system state) differs, is it a good idea to insist on following the map?

If you're doing landscaping and the map is your requirements, yes. And that's what infrastructure is comparable to (hence Terraform's name btw)

> > Ansible will lose track of your VM if you rename it

> Sure, but so will Terraform. Or worse.

No it won't, because Terraform stores the underlying platform ID in it's state. It will just know there was a rename, and will inform you it plans on rolling it back to what you have requested in the configuration. It won't delete it. Ansible will want to recreate it, with all conflicts this could bring.

> Ansible is a superset of Terraform. It's mostly a matter of culture which tool people choose, and which you think is the easiest to use.

It's a different tool for a different job (at which it isn't great due to using a markup language which really doesn't lend itself to templating with lots of templating, and a dynamic language that suffers from version and dependency hell).

Re:XML Is the Future by jerf on Monday June 26, 2023 @09:30AM (#36479439)
A great example of the narcissism of small differences [1]. Locally in the space of management tools, terraform and ansible are very different beasts, in that they can hardly even manage the same tasks. Globally, if you plot all software in the world on some big graph, they are right next to each other and indistinguishable on a plot that has "video games" and "databases" and "routing software" and "spacecraft code", etc.

[1]: https://en.wikipedia.org/wiki/Narcissism_of_small_difference...

Re:XML Is the Future by pizzafeelsright on Monday June 26, 2023 @07:18PM (#36487117)
I did a 3x of my career by doing this.

Now everything thing looks like a shell script or json exchange.

Ansible is a bunch of scripts. Terraform is a bunch of json exchanges.

Re:XML Is the Future by agumonkey on Monday June 26, 2023 @04:08AM (#36477036)
I believe there's a spiraling pattern, where the same ideas reappear every N years but with slight internal or ecosystem changes. I'm not sure if we're running or circle of if there's a real slow progress.
Re:XML Is the Future by hutzlibu on Monday June 26, 2023 @04:22AM (#36477129)
I think it is mostly just adopting. To new hardware, new demands, new plattforms.

There is maybe some progress on a academic level, but I don't think we progress fast on the fundamental level, on how to write better code. There are slight improvements here and there, but it is mostly just different. And more complex. Or rather new tools are needed because everything gets more complicated (some say bloated).

That being said, the new thing that I am learning is general purpose GPU compute. That is quite new and useful (but hard). But it is an improvement.

Re:XML Is the Future by agumonkey on Monday June 26, 2023 @05:00AM (#36477385)
Yes, that is indeed part of it. Everything changes, the ideas have to swim on top of that moving soil. And at times some integration occurs where a lot of ideas suddenly merge into a new cleaner brick.
Re:XML Is the Future by hardwaresofton on Monday June 26, 2023 @04:47AM (#36477297)
I think it's real slow progress, and sometimes even, quite fast.

It's the same ideas, but I will assure you that most of the large things that people get crotchety about are legitimate moves forward.

People were complaining about "docker" (i.e. cgroups + namespaces + some CLI UX) not too long ago and now you'd be dumb to try and deploy most applications without at least having that there.

How many people are wrangling their own cgroups and namespaces (not counting systemd, which is another thing people fought, tooth and nail)?

Should we all be doing 1 user per workload like the good 'ol days?

Or maybe 1 machine/VM per workload like the 'ol 'ol days?

Re:XML Is the Future by noduerme on Monday June 26, 2023 @12:24AM (#36475713)
I've watched this happen to so many coders in the land where people write code for companies that sell code. Personal advice: Write code for any other kind of company. They're much more resistant to fads. They don't care how you accomplish the new feature. They just want to get it done. And they certainly don't want to change their stack, ever, although in a new project you'll have more flexibility to pick the right tools than you would in a software company that's obsessed with the newest thing.
Re:XML Is the Future by deaddodo on Monday June 26, 2023 @01:11AM (#36475962)
Having worked at both, the latter type of company also has it's downsides. Primarily: a) the inverse is also true...you'll be working on some old technology that only your industry utilizes and isn't well optimized for modern use cases or is extremely niche; despite there being plentiful use cases to make the switch, it'll never be "in the budget", b) your payrate is generally going to be quite a bit lower than industry standards at app/tech companies and c) you won't get the same treatment as an engineering focused company.

The latter two are very much variable by company, but those are the general trends. They'll also vary in importance to different people. The former item, however, can be just as burn-out/tedium prone as tech company stack whiplash.

Re:XML Is the Future by noduerme on Monday June 26, 2023 @02:11AM (#36476286)
Maintaining old systems and not getting the chance to exercise your hottest take on how they should be rebuilt is often tedious as hell. But I find a lot of comfort in it. I usually find that the future road maps that stick in my head for a year or more are the ones worth a 10-year overhaul, and I like to be able to tell clients that when enough of their stack is reaching end of life, we should do this major rewrite but I already am fairly certain they won't have to do it again for another 10 years. e.g. I have yet to deploy any production code for a client running on Nodejs, but I've written enough dependable systems in it on my own free time in the last 5 years that I think I might now finally advocate for it under certain circumstances, knowing the strengths and weaknesses.

It does help - as you point out - to be in the position where the non-tech company will almost always take your advice if you tell them they need to change platforms. But the most effective way of getting yourself in that position is to prove that you exercise that option only when it truly is in their best interests.

Re:XML Is the Future by bandrami on Monday June 26, 2023 @02:13AM (#36476305)
I agree that it's dull but the fact that I still know ColdFusion 20 years later gets me a lot of work. No, it's not Silicon Valley money but it is Fairfax County money, which ain't bad.
Re:XML Is the Future by noduerme on Monday June 26, 2023 @02:36AM (#36476452)
Having a lifetime gig is worth more than all the startup stock options in the world.

But then again, I like my own yard and sitting by my fire pit with a beer, and I don't spend too much time worrying what other people have.

Re:XML Is the Future by mschuster91 on Monday June 26, 2023 @03:02AM (#36476604)
> your payrate is generally going to be quite a bit lower than industry standards at app/tech companies

And so will be the workload. No semi-mandatory after-work drinking, no constant "hustling", no bullshit.

Re:XML Is the Future by deaddodo on Monday June 26, 2023 @03:31AM (#36476781)
This is completely anecdotal, but I was far more overworked as an engineer at a non-engineering company than at any engineering company I've worked at. The entire reason I went back to that work environment was because I was tired of "wearing multiple hats" (e.g. doing three people's work) for 2/3 the pay of wearing one of those hats at some random adtech company.
Re:XML Is the Future by einpoklum on Monday June 26, 2023 @04:25AM (#36477150)
> you'll be working on some old technology that only your industry utilizes and isn't well optimized for modern use cases or is extremely niche

But it's easier to get a company to upgrade from old cruft to a commonly-used technology, of your choice and which you push, over trying to get the company to drop a new fad they've bought into ("You know, we don't really need all of those Docker images, and VMs, and Amazon Cloud services - let's just write an executable which does the thing and can be configured.")

Re:XML Is the Future by gostsamo on Monday June 26, 2023 @01:41AM (#36476097)
I work for a company which sells code and we are a counter example. We make gradual changes in the development stack and processes, every change needs a reason, and even though some changes are necessary, they will not be implemented soon.

Some possible factors are that the company is not that big and we have a feature list to deliver. We are not VC, so we cannot afford to burn money. The devs churn is low, so we don't need to be attractive to many people all at once.

TBH, I don't like it all the time, but it works and our clients are happy with the results.

Re:XML Is the Future by noduerme on Monday June 26, 2023 @02:14AM (#36476315)
Hah. That sounds like my dream job. A software company that's not controlled by VC, not burning money, actually shipping a product, and (presumably?) turning a profit... that's an actual unicorn these days...
Re:XML Is the Future by gostsamo on Monday June 26, 2023 @03:19AM (#36476696)
Profitable to the best of my knowledge. Not sure if the initial investment has been returned yet, but moving in that direction.
Re:XML Is the Future by s-lambert on Monday June 26, 2023 @05:50AM (#36477670)
Isn't this just normal business-to-business apps? They're mid-size companies that are everywhere.
Re:XML Is the Future by Pamar on Monday June 26, 2023 @02:10AM (#36476285)
This is all fine but... the rest of the world is not freezed. Let's say you are happily mantaining a stable, boring ERP app for your... cigarette lighters plant.

Out of the blue, one of your main suppliers declares they will accept orders only through a REST interface starting next quarter. And that you can/must use it to track your orders, instead of sending an email to one of their employees.

One week later, you are required to provide invoices in PDF instead of just printing on paper.

And your accounting system will switch to Oracle Finance in October...

Your ERP was developed on Progress ABL, and nobody really cared to port the old code to a web-based architecture because it was just for "internal use" and Putty was fine.

Re:XML Is the Future by noduerme on Monday June 26, 2023 @02:42AM (#36476477)
Well, I can't tell you how many dozens of times I've had to learn some stupid company's API and integrate it into software just because a client decided to do business with them. That comes with the territory, and you set up whatever you need to make it work. When it happens, it's a sprint, and you migrate everything you need to. But that's very different than migrating it because you're bored or want to sell the client a new shiny thing.
Re:XML Is the Future by Pamar on Monday June 26, 2023 @05:55AM (#36477698)
Of course, but I was just trying to explain that sometimes you are forced to innovate due to external interfaces/dependencies.

And maybe these were introduced in other companies because their IT depts. are run by "fashion of the month", but whatever the reason, you now have a problem. And if your sw and your skillset has remained frozen in jade since the early 90s... this will be painful and probably require at least one false start before getting it to work reliably.

I have noted a tendency in people who work always on "very stable" technologies to go in crisis mode as soon they have to (for example) produce a file in XML or JSON format after 2 decades of CSVs... this unfortunately almost routinely ends in stuff which is very brittle ("XSD? you do not understand, we need to produce an XML, ... I dunno what an XSD is or has to do with this requirement - except that they both start with an X, maybe - so please do not make things unnecessarily complicated and just go back to coding, we were supposed to start testing one week ago.")

Re:XML Is the Future by throw310822 on Monday June 26, 2023 @02:35AM (#36476442)
I've worked for a small company that does an old boring ERP. In C. The oldest files in the library date to the late '80s. The whole thing runs on a dime, is super fast, and a few developers could manage the needs of tens of clients.

Implementing orders in REST was probably done in a couple of weeks of work. PDFs have been there since ever.

Re:XML Is the Future by noduerme on Monday June 26, 2023 @02:44AM (#36476497)
This too. If the foundation is solid, it's easy to shift the outputs.
Re:XML Is the Future by phpisthebest on Monday June 26, 2023 @07:22AM (#36478252)
>>in the land where people write code for companies that sell code.

That is not always true, it also depends on who they are selling code do..

I know a few Orgs that by code from others, and pay $$$$ to ensure it never changes... or rather only changes in measured approved ways not drastic changes that would up in business workflows.

So I would amend your statement to where people write code for companies that sell code to startups or technology companies

if you are selling code to a 100 year old manufacturing company, or some other legacy space (healthcare, education, etc) then most likely they want stability not the new shiny

Re:XML Is the Future by jononomo on Monday June 26, 2023 @08:02AM (#36478604)
This is how you get stuck working with XML in 2023, as is the case with a woman I was just talking to the other day at my co-working space.
Re:XML Is the Future by yxhuvud on Monday June 26, 2023 @08:40AM (#36478958)
Another way is to work at one of the many places where XML (and related technologies like XSLT) make perfect sense both then and now. Working with transforming documents from one representation to another is a work that will not disappear anytime soon.
Re:XML Is the Future by bruce511 on Monday June 26, 2023 @12:39AM (#36475782)
>>when I started working in the industry, I realized that it's absolutely exhausting.

It's been this way forever. For every level of the stack. When I started the physical hardware hadn't been settled (coax, ethernet, token ring etc.)

Fortunately when I started we only got paid when we shipped. So we were motivated to ship, not be distracted by rewrites. We were also lucky that as a boot-strapped company we had no managers calling the shots. We made decisions and stuck to them, and it's paid off over the long run.

Of course the product has changed immensely over 25 years - but the core code laid down in 1996 is still integral. We've spent the time on the product, not worrying about the sexiness of the tech stack.

Which is not to say we've ignored the tech stack, it's evolved a lot, but the stack serves the product, not the other way around.

On the other hand we don't have to raise investments, we don't have to attract endless streams of new programmers, we don't have to juice a stock price, so we don't have to appear modern or hip. We can just keep doing what we do, making money, focusing on the value to customers, not being (easily) distracted by the next shiny toy.

And yeah, after a couple decades you learn to see through the hype a bit and distinguish things that are good for you, not just the flavor of the week.

Re:XML Is the Future by another2another on Monday June 26, 2023 @05:28AM (#36477560)
>(coax, ethernet, token ring etc.)

Well, some things did bring improvements, or new ways of thinking about existing problems, and some things really moved the state of the art. Taking your example of token ring -> coax (with terminators,eek!) -> ethernet is arguably a good progression (and now also wifi).

But there's also lots of churn in software and people solving the same problems in slightly different ways.

However ... this is also collateral damage from another improvement, imho - that is the ceding of control of the tech landscape from big companies (IBM, Oracle, Microsoft, Intel, Sun, Borland) to smaller open source clusters of people and VC funding. There was a time when nothing happened without some big tech company behind it, and everybody waited for (particularly MS) to bless things and provide library support, IDEs and tools.

Those days are over, but the result is a bazaar of nosql servers, messaging servers, languages and front-end JS frameworks.

Re:XML Is the Future by seanp2k2 on Monday June 26, 2023 @12:59AM (#36475891)
Stuff like this is why the notion that AI will eat all the software jobs in a few years is so ridiculous to me: who will maintain all the infra? Maybe AI will very eventually, but there's still a whole lot that needs to happen for the AI magic to magic, and it's not like VPs are going to be able to write implementable specs in enough detail for an AI SWE to implement them, wire them into the right branch / tag / whatever in the release system, communicate with stakeholders to plan a deployment, do the release, monitor for bugs / regressions, patch as necessary and port those into the dev branch, etc etc.

There's a whole lot more to modern SWE roles than just staring at an IDE with the job "implement a function that given X returns the square of X" type stuff that current AI can implement well.

Re:XML Is the Future by sublinear on Monday June 26, 2023 @02:01AM (#36476223)
> it's absolutely exhausting

I'm not young, yet I don't find any of this all that bad.

Maybe I'm an outlier, but I see refactoring and learning new tools as just keeping the blade sharp. Migrating to new frameworks, tools, etc. is just superficially iterative. I've yet to see some kind of massive paradigm shift blow me away and stress me out.

Re:XML Is the Future by fodkodrasz on Monday June 26, 2023 @03:04AM (#36476619)
I wanted to share my ideas, but it just turned into a rambling:

The problem is not with massive paradigm shifts... actually we are yet to see something like that. The constant busywork on industrial scale is what the problem is, the constant reinvention of the wheel in a way that is somewhat still incompatible yet the same thing. Most change is only for the sake of change, for NIH-syndrome. when a solution for a problem gets half-decent, and almost as good as it was in the windows 2000 times, then it gets forked/dumped and a new half as god fad appears...

There is no problem with learning new tools, but learning a new UI framework every 2 years just to be constantly half-as capable as Delphi was (okay, with rounded corners and animations, I give you that) can be really tiresome.

Cloud vendors changing their line-up constantly so that your certifications expire, and they can remove the really good value for the buck services and push the shiny new globally replicated and 10x more expensive new stuff (which delivers value for many, but the barebones stuff also did for many others).

Just my 0.02$, probably saw too many lets rewrite in $current-thing and don't use $industry-standard-battle-tested-thing, as it is hard to learn it, but let's write one from scratch! (last time a team in a job decided that configuring HAProxy (my suggestion to get stuff done cheaply and quickly) is too hard, it is better to write a high performance reverse proxy, because it will be our thing! (I guess they were more interested in their resumes than in the company's interests). Since then that company is bankrupt... who would've thought)

Re:XML Is the Future by einpoklum on Monday June 26, 2023 @04:30AM (#36477189)
> as just keeping the blade sharp

Replacing weapons and keeping blades sharp is not the same thing. Now, the metaphor kind of breaks down because new weapons are sharp, but abilities with a new technology are typically not, i.e. you use new tech as somewhat of a blunt instrument until you learn the finer points of it - and until it develops and matures enough itself.

So, if you want to use "sharp blades" - don't switch technologies, but rather keep with the updates to those you already know.

Re:XML Is the Future by CuriousSkeptic on Monday June 26, 2023 @05:19AM (#36477507)
I’ve been in that camp the last 20 years, and even yearned for a paradigm shift or two. But I have to say, the coming shift from formal languages, type systems and somewhat predictable failure modes to… “prompt engineering” has me a bit worried
Re:XML Is the Future by tsguy on Monday June 26, 2023 @02:21AM (#36476357)
I checked terraform and lambda stuff in 2016 and then decided to continue with ECS bcz as an entrepreneur i find it to wonderful and time and money saving you know.

Easy to deploy and also you can utilise cheap spot instances to fullest.

Re:XML Is the Future by mcv on Monday June 26, 2023 @03:09AM (#36476639)
Yeah, you can't jump on every hype.

I started in web dev almost 20 years ago (did some Visual C++ before that). First job was everything XML. We had our open source CMS that stored all documents as XML and used XSLT to transform it into the HTML we needed. Was pretty cool, but there's always something that didn't fit that paradigm. Some coworkers went a bit overboard and used XSLT to generate the XSLT to create the HTML. But it all works as long as you cache aggressively.

Second was Runy on Rails with JQuery. And eye-opener for me. Very cool to work with. Third job was similar, but using Groovy instead of Ruby. After that, I ended up in SPA-land: first Angular, then Vue, now React. Backends in either Java or Node.js.

I'm still doing that, only now everything needs to be in Docker and Kubernetes.

I still don't know why I should ever need microservices. Our GraphQL. We actually considered GraphQL for previous project, and decided not to because it looked way too complicated. It sounds like it might fit with using a Graph DB (I'm a big fan of neo4j), but it doesn't. At my current project, they made that decision before I joined, and they've since realised that they don't need GraphQL after all, but it's in there now, so they just work around it.

Some of the hypes worked very well for me (XML, jQuery, Ajax, SPA), others seem to work well for others but not me (docker, kubernetes), and some I really don't see the point in (microservices, GraphQL), but I assume there are use cases where they shine.

But don't blindly adopt everything. First check if it actually fills a need you have. And how it will fill that need.

Re:XML Is the Future by Blaiz0r on Monday June 26, 2023 @03:21AM (#36476708)
Microservices are more an organisational thing than a recommended pattern, when a project grows and wants to hire more staff to increase its bandwidth then microservices are a great way to support that, the additional benefit is that they work great in a CI/CD setup so you can release seamlessly.

GraphQL from what I can tell supports web developers rewriting their APIs when they need to instead of waiting on back-end teams to support them.

Re:XML Is the Future by mcv on Monday June 26, 2023 @03:35AM (#36476805)
Most of my projects have just a single team in charge of a single code base, so there seems to be no need for microservices at all, and yet some people keep bringing up that we should really look into microservices.

My impression is that GraphQL is great if you're building an api that's going to be used by lots of different teams with different needs and the api developer doesn't know what they are. Again, with a single team doing everything, there's no need for it at all. But we're using it anyway.

Also, they keep talking about a Single SPA Application, and I can't tell if that's just a redundant way to say SPA, or if it's really something new, or if they're just messing with me.

Re:XML Is the Future by noisy_boy on Monday June 26, 2023 @11:20AM (#36480832)
> My impression is that GraphQL is great if you're building an api that's going to be used by lots of different teams with different needs and the api developer doesn't know what they are.

This has been my experience as well. It provides flexibility to the consumers of the API to structure things how they want and fetch only what they need. E.g. if you add a new field, there isn't any impact on existing users to make any changes since they are not specifying it in their current request anyway. To certain extent, that also helps with things being somewhat future proof because even if you knew what the users want today, you can't predict what they will want tomorrow.

Having done a bunch of REST and GraphQL APIs, the only thing I would say for GraphQL is to avoid re-inventing the wheel and use a stable third-party library to do as much heavy lifting as possible so that you can focus on the logic side of things.

Re:XML Is the Future by throwaway2037 on Monday June 26, 2023 @05:16AM (#36477491)
Did you ever try the Microsoft Visual Studio XSLT debugger from DotNet? The first time I tried it from C# was mind-blowing. Suddenly, it became possible to manage complex XSLT scripts!
Re:XML Is the Future by mcv on Monday June 26, 2023 @11:36AM (#36481131)
Never used it. We used Eclipse.
Re:XML Is the Future by pookha on Monday June 26, 2023 @10:13AM (#36479891)
Somewhere out there in the known universe theirs cobalt developers that have avoided CSS, SOAP, Oracle J2EE, reactivesvelteinangularvue's, javascript servers, shitty facebook ideas, nine thousand line YML files, micro bullshit (microsoft, microservers), "containers" (and solaris zones before that) AND there's nobody pining to replace them with LLM models.
Re:XML Is the Future by spiralx on Tuesday June 27, 2023 @12:25PM (#36495058)
> First job was everything XML. We had our open source CMS that stored all documents as XML and used XSLT to transform it into the HTML we needed.

Docato/XHive? Been there as well.

Re:XML Is the Future by CJefferson on Monday June 26, 2023 @03:18AM (#36476692)
I'm constantly sad there isn't any good writing on this topic.

Does anyone have any suggestions on anything to help me keep up with the basics of new fads?

I would love a monthly (doesn't have to be exactly monthly, but the point is occasional) magazine, which was the equivalent of those old magazine with basic tutorials, which would give overviews, and comparisions, of all the various modern techs floating around.

I do occasionally find a new person's blog to subscribe to, but I've never found a good general source.

Re:XML Is the Future by makeitdouble on Monday June 26, 2023 @03:19AM (#36476699)
To give another perspective, at my first job deploying meant sshing into production and execute a make script. It worked 98% of the time, and you'd be having fun the 2% else. It sure wasn't the state of the art, but wasn't something people would yell at you for.

We needed windows machine because of corporate policy and remoted into a Solaris box to dev, as a vague replica of production.

Fast forward to today, and we can run a production replica on our local machines at home, the CPU architectures aren't even the same, and code will be deployed through the CI automatically after the tests all pass.

Sure not all changes are meaningful, but in the grand scheme of things the field is moving forward in spades. I certainly wouldn't want to go back a few decades.

Re:XML Is the Future by coldtea on Monday June 26, 2023 @03:50AM (#36476903)
>Fast forward to today, and we can run a production replica on our local machines at home, the CPU architectures aren't even the same, and code will be deployed through the CI automatically after the tests all pass.

And someone we squandered most of the CPU performance increases in the process, and the super-duper architecture/CI/delivery pipeline fails almost the same percentage of the time, but needs 10x the people to keep it running...

Re:XML Is the Future by makeitdouble on Monday June 26, 2023 @04:49AM (#36477312)
CI and delivery failing 2% of the time just means you haven't deployed and you just retry. At least you're not poking things in prod.

I'm with you on the CPU gains going down the drain and 10x more people working on it, but it's also a sign that we're talking IT operations more seriously and there's enough money to cover these kind of inefficiencies.

Re:XML Is the Future by shocks on Monday June 26, 2023 @04:19AM (#36477107)
Here’s another perspective:

A decade ago you could deploy an internal PHP app to a box and forget about it for a few years, then fix a minor bug by sshing in, viming a file, and hacking it a few times.

These days, if you leave the app untouched for six months that 10 minute fix becomes 2 hours of fixing a broken docker build. :)

Re:XML Is the Future by ilyt on Monday June 26, 2023 @04:23AM (#36477139)
As an admin of PHP apps at that time I can sincerely say screw you, you're lying. PHP apps breaking because new version of PHP shat on compatibility was pretty common, and weirdly enough got more common in newer versions.

You also had to keep unholy combo of php extensions (why that garbage is in app server and not app) and server config because the special little retard that designed the app decided he must do something different.

And forget about ever leaving apache, if it doesn't use some apache module to fix PHP/developer ineptitude it will at least have half of the request routing logic in .htaccess file.

Re:XML Is the Future by shocks on Monday June 26, 2023 @04:32AM (#36477198)
> forget about it for a few years

No version upgrade required. :D

Re:XML Is the Future by andrelaszlo on Monday June 26, 2023 @05:21AM (#36477520)
Haha yeah I can say, with the same sincerity, that I get occasional calls about fixing PHP apps that I built 2007-2013. They've been running (without upgrades) on some forgotten server in a multinational corporation.

I tell them that they should let their compliance department know, that the version of PHP isn't even supported, and I list some of the thousand security fixes that they aren't using.

I usually end up VPN/FTP:ing into a forgotten era to add the fixes and I definitely don't want to go back.

Re:XML Is the Future by progmetaldev on Monday June 26, 2023 @09:21PM (#36487920)
I had this happen about a year and a half ago with an application I wrote in 2009. Finally got them to allow me to rewrite everything in C#, allowing me to keep up to date on security vulnerabilities and performance improvements, without having to do much but run through a series of tests when a NuGet package or .NET version upgrade is released. NuGet with current .NET is a far different beast now, than when you used .NET Framework and plenty of XML assembly binding.
Re:XML Is the Future by mm007emko on Monday June 26, 2023 @06:02AM (#36477731)
At the time we were reluctant to update even our linux servers. We had only critical security fix repos enabled and checked them once a week.

No, we didn't update PHP unless strictly needed.

Re:XML Is the Future by ilyt on Monday June 26, 2023 @07:37AM (#36478375)
If you piss on security sure but then every language is "easy" if you just need to deploy once and forget about the server for forever
Re:XML Is the Future by edejong on Monday June 26, 2023 @04:24AM (#36477140)
In the meantime, your PHP app had 40 major security flaws, no meaningful monitoring, a DB that wasn't backed up and major data consistency problems. Also, when your box's hdd crashed, you lost all those minor changes you had vim'ed over the years. But for the rest, yeah, all is fine.
Re:XML Is the Future by shocks on Monday June 26, 2023 @04:37AM (#36477230)
If you forget about a PHP container for a few years it will /also/ have 40 new vulnerabilities. Actually, containers are worse because OS updates of core shared libraries do nothing. You have to rebuild every damn container.

Setting up monitoring for your docker containers is also a whole thing. :)

I think you’re taking my example a little too literally. My point is not that docker/k8s/whatever is bad; just that the ‘new’ adds features at the cost of simplicity.

Re:XML Is the Future by makeitdouble on Monday June 26, 2023 @04:58AM (#36477370)
The biggest thing with containers is, these 40 vulnerabilities won't matter as much if they're about erasing your directories or killing your machine. It will get rebooted in a pristine state and an attacker would need to stick there killing it at every reboot to have lasting effect.

Which is also the point of monitoring a container, which is fairly reliable nowadays, compared to managing your own health check service to ping your box to check if it's alive.

All in all, I think k8s is way too complicated for what it does for most people, but administrating servers was also a complex task to begin with, and the things sys admins were dealing with looked nightmarish to me. Heck, there was a time companies would have their own SMTP in house...

Re:XML Is the Future by dumpsterdiver on Monday June 26, 2023 @06:53AM (#36478082)
> won't matter as much if they're about erasing your directories or killing your machine

Those sort of attacks have tapered off though, right? Unless you're engaged in a specific feud, or have caught the ire of a social justice warrior, these days we're mostly looking at data exfiltration as the primary goal. That being said, there are a lot of ongoing feuds and active social justice warriors.

Re:XML Is the Future by dns_snek on Monday June 26, 2023 @07:24AM (#36478283)
If we're talking about common, automated attacks, I think the game plan for the past few years has been to probe for systems vulnerable to RCE, install a crypto miner, join the server to a botnet and see how long it takes its owner to notice.
Re:XML Is the Future by dumpsterdiver on Monday June 26, 2023 @08:05AM (#36478628)
Aha, how could I forget the crypto mining botnets. I agree.
Re:XML Is the Future by BirAdam on Monday June 26, 2023 @07:35AM (#36478368)
Layering more abstractions on top of what was already complicated doesn’t fix the complications below, it just hides them. You then have to hope that there’s not a bug somewhere in between those layers. Additionally, each new layer has a cost in performance. More layers means more compute, and eventually mean more money. If you’re Netflix, it’s worth it, if you’re not… what admins dealt with before wasn’t so bad. Now that that job has largely been killed and renamed 20 times, it’s far worse. Admins don’t just have to deal with a server, they have to deal with a server and 60 containers which are just little baby servers.
Re:XML Is the Future by TeMPOraL on Monday June 26, 2023 @05:34AM (#36477593)
I think what people are missing is that sure, code "rots", at the very least because of security patches. But since this all happens to everything simultaneously, the more distinct layers and support tools you have in your stack, the more often you have to deal with something breaking in a nontrivial way.

In short: the more moving parts you have, the less time you have between major malfunctions.

(Manufacturing and hardware world understands it well, which is a big part in why they like integrating things so much.)

So e.g. over in the backend-land where I live, it used to be that I had to occasionally update the compiler or one of the few third-party dependencies that I used. Today, I have many more libraries (to the point there's something to update for security reasons roughly once a month, on average), and on top of that, I have CI/CD introducing its own mess, Conan updates which occasionally get messed up, or make some existing recipes incompatible, CMake updates which are done unexpectedly and break stuff, now also Docker is adding more of its own problems, etc. So I have to deal with some kind of tooling breakage every other week now.

And always, always, when I think it's all finally OK and I can get on with my actual job, some forgotten or hidden component craps itself out of the blue. Like that time our git precommit hooks broke for me, because someone changed them in a way that doesn't work with my setup. And then me wasting a day on trying to fix it, eventually giving up and degrading my setup to unblock myself. Or another day where, for no apparent reason, some automation that made automated commits to some git repos started losing Change-ID headers in commit messages, making Gerrit very sad, leading to several people wasting a total of several person-days trying to fix it. Etc.

There's always something breaking, the frequency of such breakages seems to be increasing, and it's a major source of frustration for me in this job. Which is why I too am often thinking back to "good old days", and am increasingly in favor of keeping the amount of dependencies - both libraries and tooling - to a minimum.

Re:XML Is the Future by shocks on Monday June 26, 2023 @07:11AM (#36478199)
Yea, it’s definitely about trading features for simplicity.
Re:XML Is the Future by TeMPOraL on Monday June 26, 2023 @07:23AM (#36478264)
Right, and it's easy to think about all the winnings when things go right - it's harder to think about increased frequency and cost of failure due to increase in complexity and number of independently moving parts.
Re:XML Is the Future by mrweasel on Monday June 26, 2023 @05:55AM (#36477692)
> You have to rebuild every damn container.

I can say with great certainty: Almost no one rebuilds their damn container anywhere near as often as the the gray-beard in the basement updates the Debian packages on the the server that runs the container.

I had the debate with a client, we did monthly security update, unless something horrible happened. The client was rather upset that we didn't patch more frequently, like weekly or daily. My argumentation is that it doesn't really matter if the Linux kernel or bash is patched, when the only thing running is a container with a beta version of Tomcat that hasn't had security updates applied in three years.

Even worse are the people who just pull things from Docker Hub, with no plan as to how and when they'll pull newer versions. But fine, let's just keep running KeyCloak from 2017, and that old Postgresql image which the developer never configured to do backups, I'm sure it's fine.

Re:XML Is the Future by mrighele on Monday June 26, 2023 @07:47AM (#36478486)
> I can say with great certainty: Almost no one rebuilds their damn container anywhere near as often as the the gray-beard in the basement updates the Debian packages on the the server that runs the container.

Most probably the gray-beard simply enabled "unattended-upgrades".

You can do something similar with a container (track the security fixes for the packages used, force rebuild and deploy when needed), but it is a bit of work and I don't know of any ready solution.

Re:XML Is the Future by xorcist on Monday June 26, 2023 @07:26AM (#36478297)
> In the meantime, your PHP app had 40 major security flaws, no meaningful monitoring,

How does Kubernetes, microservices and front end frameworks fix that?

They don't. In fact, as someone who works at the more modern end of these things, I'd suspect that "no meaningful monitoring" probably correlates quite well with cloud era microservices thingies.

But we can't blame the tools, that space is just younger and by nature contains more immature stuff.

I don't think the argument here is for keeping things out of version control and monitoring. It's that you can actually leave stuff alone for several years, come back and find it working just as before, when the layers underneath doesn't constantly change. That can be liberating.

Re:XML Is the Future by CoastalCoder on Monday June 26, 2023 @07:48AM (#36478497)
> But we can't blame the tools, that space is just younger and by nature contains more immature stuff.

I think the article's point was that the industry is perpetually young and immature because it keeps (unnecessarily) chasing fads.

Re:XML Is the Future by Quarrelsome on Monday June 26, 2023 @07:49AM (#36478503)
> How does Kubernetes, microservices and front end frameworks fix that?

Doesn't being in a container mean its much easier to rebuild it from zero and thus allowing security updates to be more regular?

Re:XML Is the Future by otabdeveloper4 on Monday June 26, 2023 @08:16AM (#36478717)
Not really. A "container" is usually just an instance of a Linux distribution, and the work involved in updating it is roughly the same.
Re:XML Is the Future by edejong on Monday June 26, 2023 @08:44AM (#36478998)
In the 27 minutes after you wrote your comment, our CI/CD rebuild two containers from a latest snapshot. No manual work involved.
Re:XML Is the Future by otabdeveloper4 on Tuesday June 27, 2023 @03:49AM (#36490061)
Good for you, some people can do automatic unattended OS updates too.

There's no benefit to using containers here, only more pain.

Re:XML Is the Future by collinmanderson on Tuesday June 27, 2023 @10:47PM (#36501665)
One benefit of containers is easy rollback.
Re:XML Is the Future by shocks on Monday June 26, 2023 @09:55AM (#36479697)
IME, this is rarely true; hence “2hrs fixing docker build”.

It’s really difficult to pin everything. Even if you manage that, upstream resources change/move.

Re:XML Is the Future by steveBK123 on Monday June 26, 2023 @08:00AM (#36478584)
As a "not a cloud guy" who only recently got heavily exposed to it.. I found the state of the art / CloudOps attitudes towards monitoring astonishingly Stone Age.

Yeah observability is great, but no one I've seen in cloud manages to launch with it. So in place of SRE org with full observability stack, they launch with effectively nothing.

Strong attitudes of "we don't measure hardware metrics like cpu/memory/disk, we measure customer facing stuff like throughput/error rates etc". Sounds good, but what do you think happens to those if you run out of disk bro? Pretty sure the running out of disk happens first. Imagine if you could like.. catch it?

Re:XML Is the Future by edejong on Monday June 26, 2023 @08:42AM (#36478977)
CPU/Memory: scale horizontally when needed. Monitor cost.

Disk: essentially limitless. If disk of VM runs out, node will crash, new node will start. Service should keep running on other nodes meanwhile. If restarts happen too often, throughput/error rate will suffer or cost will rise.

Modern mentality is "let it crash" [0]. Software has bugs. Design so it can crash and scale depending on need.

[0] https://medium.com/@vamsimokari/erlang-let-it-crash-philosop...

Re:XML Is the Future by jerf on Monday June 26, 2023 @09:27AM (#36479411)
Letting an Erlang process crash is letting a process holding a small collection of resources, maybe a single TCP connection and several kilobytes of local state. It does not necessarily scale beyond that. Pretty much by definition, if you've got something that can run out of disk, when it runs out of disk and you nuke it, you're taking out a lot more than a single connection and a few kilobytes of state.

And "let it crash" is hardly "My service is invincible!" I'm sure any serious Erlang deployment has seen what I've seen as well, which is a sufficiently buggy process that crashes often enough that the system never gets into a stable state of handling requests. "Let it crash" is hardly license to write shitty code and let the supervisor pick up the pieces. It's a great backstop, it's a shitty foundation.

Re:XML Is the Future by sterlind on Monday June 26, 2023 @01:48PM (#36483178)
I built a distributed system once on two principles: 1. let it crash, 2. make everything deterministic. obviously, this resulted in crashes being invisible and transient (good) or an infinite crash loop (bad.)

I haven't used Erlang, but my impression is that it's probably the same experience there?

Re:XML Is the Future by jerf on Monday June 26, 2023 @03:30PM (#36484578)
The way it builds on immutability means it naturally can lean in that direction, but the way it tends to be used for networks a lot undoes that because network communication by its nature is not deterministic in the sense you mean.

In my case, IIRC, it was something to the effect of, a lot of our old clients out in the field connected with a field that crashed the handler. Enough of these were connecting that the supervisor was flipping out and restarting things (even working things) because it thought there was a systemic issue. (I mean, it was right, though I had it configured to be a bit to aggressive in its response.) The fact that I could let things crash didn't rescue the fact my system, even if I fixed that config, would strain its resources constantly doing TLS negotiations and then immediately crashing out what were supposed to be long term connections.

Obviously, the problem was in the test suite, we were able to roll back, address the problem, ultimately this was a blip not a catastrophe. I just cite it as a case where "let it crash" didn't save me, because the thing that was crashing was just too broken. You still have to write good code in Erlang. It may survive not having "great" code but it's not a license to not care.

Re:XML Is the Future by edejong on Monday June 26, 2023 @03:33PM (#36484629)
Let it crash is anti-fragile. Either you understand that, or you try to make super robust and super expensive applications.
Re:XML Is the Future by jerf on Monday June 26, 2023 @04:43PM (#36485569)
Using Taleb's nomenclature, let it crash is not anti-fragile at run time. Erlang does not get progressively better at holding your code together the longer it crashes. It is only resilient and robust. Which is ahead of a lot of environments, but that's all.

Many software development processes considered as a whole are anti-fragile... mine certainly is, which is a great deal of why I love automated testing so much (I often phrase it as "it gives me monotonic forward progress" but "it gives me antifragility" is a reasonably close spin on it too)... but that's not unique to Erlang nor does Erlang have anything special to help with it as everything Erlang has for robustness is focused at run time. You can have anti-fragile development processes with any language. (The fact that I successfully left Erlang for another language entirely is also testament to that. I had to replace Erlang's robustness but I didn't have to replace its anti-fragility, since it didn't have it particularly.)

Re:XML Is the Future by namaria on Tuesday June 27, 2023 @05:18AM (#36490658)
Anti fragility is just a fancy name for 'ability to learn'. Erlang error handling philosophy enables learning by keeping thing simple and transparent. It's easy to see some component keeps failing, it doesn't bring your whole app down and you can look into it and improve it. Adding tonnes of third party machinery may be robust or even resilient, but if it makes things more opaque or demands bigger teams of deeper specialists, it precludes learning. Thus is not 'anti fragile'. You can keep your ability to learn healthy without Erlang, and you can use it without learning much over time.

It's not the tool, it's how you use it.

Re:XML Is the Future by steveBK123 on Monday June 26, 2023 @08:53AM (#36479093)
This is an adequate philosophy for like.. a CRUD app, some freemium SaaS, social media, etc. Stuff with millions of users and billions of sessions, etc.

However there are industries applying these lessons in HPC / data analytics / things that touch money live .. operating on scales of users in the 10s to maybe 100s. So stuff where downtime is far more costly both in dollars and reputation.

I'm also intrigued by the constant cloud refrain of "stuff crashes all the time so just expect it to" coming from a background where I have apps that run without crash for 6 months at a time, or essentially until the next release.

I'm all for scaling, recovery, etc.. I just fail to understand why it is desirable for this to be an OR rather than an AND.

What if stuff was highly recoverable and scalable but also.. we just didn't run out of disk needlessly?

Re:XML Is the Future by tivert on Monday June 26, 2023 @09:37AM (#36479517)
> I'm also intrigued by the constant cloud refrain of "stuff crashes all the time so just expect it to" coming from a background where I have apps that run without crash for 6 months at a time, or essentially until the next release.

IMHO, those aren't mutually exclusive. Your app code should be robust enough to run 6+ months at at time, and the "stuff crashes all the time so just expect it to" attitude should be reserved for stuff outside your control, like hardware failures.

Re:XML Is the Future by steveBK123 on Monday June 26, 2023 @10:17AM (#36479940)
Right, which is why I think brushing aside actually monitoring basic hardware stats that are leading indicators of error rates / API issues / etc makes no sense.
Re:XML Is the Future by pdimitar on Monday June 26, 2023 @12:56PM (#36482414)
It looks like you misunderstood the article. "Let it crash" in the BEAM VM world pertains to a single green thread / fiber (confusingly called "process" in Erlang).

It pertains to e.g. single database connection, single HTTP request etc. If something crashes there your APM reports it and Erlang's unique runtime continues unfazed. It's a property of the BEAM VM that no other runtime possesses.

"Let it crash" is in fact "break your app's runtime logic to many small pieces each of which is independent and an error in any single one does not impact the others".

Scaling an Erlang node is very rarely the solution unless you literally run out of system resources.

Re:XML Is the Future by wizofaus on Monday June 26, 2023 @03:53PM (#36484926)
Is that so different to how Java+Tomcat or .NET+IIS work? A crash handling one request generally can't/doesn't affect the ability to handle other requests. Unfortunately it does often mean you have limited control over how the end-user perceives that one failed request.
Re:XML Is the Future by pdimitar on Monday June 26, 2023 @04:10PM (#36485155)
It is only the same when you observe the visible results and your APM, and nowhere else. The stacks you mention -- and many others -- engage much more system resources per request compared to the BEAM VM. I have personally achieved 5000 req/s on a 160 EUR refurbished laptop with a Celeron J CPU, a pretty anemic one you know, in my local network -- an Elixir/Phoenix web app; Elixir steps on Erlang if you are familiar with that -- and that's without even trying to use cache.

RE: error handling, Elixir apps I coded and maintained never had a problem. Everything was 100% transparent which is another huge plus.

In general CGI and PHP had the right idea from the start but the actual implementations were (maybe still are? no idea) subpar.

Erlang's runtime is of course nowhere near what you will get with Rust and very careful programming with the tokio async runtime, but it's the best out there in the land of the dynamic languages. I've tried 10+ languages which is of course not technically exhaustive but I was finally satisfied with making super parallel _and_ resilient workloads when I tried Elixir.

For a lot of tasks I can just code in the Elixir REPL and crank out a solution in an hour, including copy-pasting from the REPL and into an actual program with tests. Same task in Rust took me a week, just saying (though I am still not a senior in Rust; that's absolutely a factor as well) and about 3/4 of a day in Golang.

The only other small-friction no-BS language and ecosystem that came kinda close for me is Golang. I like that one a lot but you have to be very careful when you do true parallelism or you have to reach for a good number of libraries to avoid several sadly very common footguns.

Re:XML Is the Future by edejong on Monday June 26, 2023 @03:56PM (#36484960)
I understood the article just fine. The "Let It Crash" philosophy is scale invariant.

Please read the last three paragraphs in [0]: "a well-designed application is a hierarchy of supervisor and worker processes" and "It handles what makes sense, and allows itself to terminate with an error ("crash") in other cases."

I've personally designed and co-implemented mission critical real-time logistics systems which dealt with tens of thousands of events per second, with hundreds of different microservices deployed on a cluster of 14 heavy nodes. Highly complex logic. At first we were baby-sitting the system, until it became resilient by itself. Stuff crashed all the time. Functional logic was still intact. Then we had true silence for months on our pager alerts.

I call it anti-fragile and Taleb is right. You can't make a system resilient if you don't allow it to fail.

[0] https://wiki.c2.com/?LetItCrash

Re:XML Is the Future by wizofaus on Monday June 26, 2023 @03:46PM (#36484786)
How is that better than a simple monitor/alert for low disk space? That low disk space is likely caused by having an application store too much cumulative data in log files or temporary caches etc. and often easy enough to fix. And many applications out there simply don't need the level of scalability and extra-robustness you need that you can still expect decent levels of service in the immediate aftermath of having one node go down. Certainly from my experience it's less work (and cost) to put measures in place to minimise the chances of a fatal crash than it is to ensure the whole environment functions smoothly even if parts of it do crash regularly. I'd also note we can be grateful that the developers of OSes, web servers, VMs and database servers don't subscribe to "let it crash"!
Re:XML Is the Future by steveBK123 on Monday June 26, 2023 @08:35AM (#36478913)
And I would add - All the GOOD cloud people I know are GOOD linux people. It is a prerequisite.

However theres lots of cloud people who don't know linux.

Therein lies the challenge. Too many of these cloud devs forget that whether its "server less" or not, theres a .. server, somewhere.

All the layers of abstraction work when they work, and when they don't .. best of luck figuring out what's going on in a timely fashion. Hope you aren't running any money on top of it.

Re:XML Is the Future by edejong on Monday June 26, 2023 @08:36AM (#36478924)
* k8s helps because you keep your application online during rolling updates. You keep your changes relatively small and can test your changes in isolation.

* microservices help security because for each service you write, you create a minimal surface area (as opposed to monolithic applications where each method has access to maximum dependencies).

* microservices also help monitoring, because failures can be contained and one application does (should) not impact another. This means that your focus of monitoring is on application performance, and less on the underlying system architecture.

* monitoring can be a cross-cutting concern. For example, you can monitor all HTTP requests by instrumenting your ingress layer. Similarly, you can support a unified authorisation scheme by bringing this to the ingress layer. Even more, using microservices, you can independently promote services to production (sort of like feature toggles) or do green/blue promotion.

* security of your microservices is improved, because you can independently upgrade your dependencies per service. Many older monoliths are 'stuck' in a certain dependency configuration and cannot be upgraded without a 'big bang' of expensive dependency resolution and testing.

I could give many more examples, but I hope this captures the spirit a little.

Re:XML Is the Future by mrighele on Monday June 26, 2023 @07:42AM (#36478431)
> In the meantime, your PHP app had 40 major security flaws

I just did a "npx create-react-app text" and I got

"74 vulnerabilities (69 moderate, 5 high)"

40 major security flaws in 10 years sounds almost like a bargain.

Re:XML Is the Future by Quarrelsome on Monday June 26, 2023 @07:53AM (#36478521)
now read those flaws, compare them to the worst in 2004 and tell me they're the same. They're not the same because the internet was insecure as fuck in 2004 and these days security researchers motivations to receive bounties result in considerably more situational (and significantly less severe) security issues.
Re:XML Is the Future by papruapap on Monday June 26, 2023 @09:26AM (#36479401)
create-react-app has been discouraged to use for a couple of years now, not really sure if the React team is still supporting it.
Re:XML Is the Future by firecall on Monday June 26, 2023 @09:52AM (#36479665)
April 2022 was the last maintenance release.

Out of curiosity, why is it discouraged?

I’m not really in the React world, but have been fixing up a Create React App for a client recently, so learned a bit more about it.

Re:XML Is the Future by rerdavies on Monday June 26, 2023 @02:25PM (#36483674)
So how are you supposed to create static react app now?
Re:XML Is the Future by xdennis on Monday June 26, 2023 @04:29PM (#36485388)
They no longer want you to create a React app by itself[1], but instead use Next.js, Remix, Gatsby, or Expo.

[1]: https://react.dev/learn/start-a-new-react-project

Re:XML Is the Future by rerdavies on Monday June 26, 2023 @08:06PM (#36487496)
None of which are static. How are you supposed to create a static React app?
Re:XML Is the Future by cowoder on Monday July 03, 2023 @03:38AM (#36569968)
You can use vite for that
Re:XML Is the Future by commandlinefan on Monday June 26, 2023 @09:29AM (#36479429)
I think the takeaway here is: programming is hard, and we deserve more money.
Re:XML Is the Future by xdennis on Monday June 26, 2023 @04:24PM (#36485330)
The sad part is that much of what makes programming hard is the fault of programmers (primarily the endless churn, but others too).
Re:XML Is the Future by datavirtue on Tuesday June 27, 2023 @10:18AM (#36493157)
Shiney new app has no monitoring, 40 security flaws, and a ultra-modern cloud database that promotes data consistency issues. But all the devs you can hire act like they might know something about this mess. They really don't.
Re:XML Is the Future by ubertaco on Monday June 26, 2023 @09:52AM (#36479670)
>then fix a minor bug by sshing in, viming a file, and hacking it a few times.

Yeah, screw version control! Who needs any record of the change you made? If you have to move the code or redeploy it somewhere because that server goes down or something else changes, _real_ 10x rockstar ninjas remember every change they've made for the last several years.

Re:XML Is the Future by zdragnar on Monday June 26, 2023 @10:01AM (#36479764)
Not to mention the paper trail needed for any meaningfully regulated industry. The thought of someone just ssh'ing into an application with access to PII or HIPAA regulated data and being able to tweak the production code is nightmare fuel.
Re:XML Is the Future by sakopov on Monday June 26, 2023 @03:37AM (#36476821)
Around the time Angular came out with v2 and everyone basically realized that they either had to completely rewrite their Angular apps or spend the same effort to migrate to React (which was the new hotness at the time) I really started contemplating whether it's possible to stay sane while keeping up with the pace of change in both back-end and front-end paradigms. I ended up switching from full-stack to back-end dev. I don't know if it's just me, but now it seems like things have started to calm down and we're just iterating on existing problem sets and frameworks rather than throwing everything out and starting over. Does anybody feel the same? I actually think this is the best time to dive back into full stack dev.
Re:XML Is the Future by boffinAudio on Monday June 26, 2023 @03:57AM (#36476950)
Use what works. Ship code. Support your customers. Help them improve their lives.

All other considerations are secondary. Including whether or not your peers approve of your code.

Always remember: the User is king. Programmers are nothing without users, no matter what technology they apply to the situation.

Sounds like you've shipped, and shipped often. GOOD!

Re:XML Is the Future by flir on Monday June 26, 2023 @07:05AM (#36478162)
But there are so many layers of abstraction between me and my user... (human layers, not software layers)
Re:XML Is the Future by boffinAudio on Monday June 26, 2023 @07:10AM (#36478195)
All the more reason for you to keep the user in mind while you wade through the crud.
Re:XML Is the Future by andruby on Monday June 26, 2023 @08:54AM (#36479097)
Do you think there are too many layers in between? Can you help reduce the number of layers?
Re:XML Is the Future by JBiserkov on Monday June 26, 2023 @04:00AM (#36476975)
> But it feels like I'm stuck in a Franz Kafka novel.

Director of O(o)ps: Funny that you should mention that...

Re:XML Is the Future by JBiserkov on Monday June 26, 2023 @04:01AM (#36476987)
Re:XML Is the Future by TeMPOraL on Monday June 26, 2023 @04:40AM (#36477253)
Franz Kafka meets the Wild West.
Re:XML Is the Future by agumonkey on Monday June 26, 2023 @04:04AM (#36477012)
somewhere, deep in an archive room, a cobol developer is smiling
Re:XML Is the Future by einpoklum on Monday June 26, 2023 @04:19AM (#36477112)
This is a benefit (non-commercial) FOSS has over software authoring in commercial corporations. Developers get to call the shots, and usually, don't bend to such passing fads.

> I don't even know how I would do it.

Depends on the software you're writing of course, but the core would probably be some libraries with C (and maybe other language) bindings, some command-line executables, and anything else - above that.

Re:XML Is the Future by andruby on Monday June 26, 2023 @04:23AM (#36477136)
I can imagine this is frustrating and have experienced people wanting to push the "latest trend". My usual way to approach this is to ask them to explain to me the _why_. Why is this new thing better? What specifically is it better at? How? What trade-offs does it make?

More often than not, they aren't able to properly articulate the why and the trade-offs involved. Sometimes they do fully understand the trade-offs and that leads to good discussions.

Re:XML Is the Future by samsquire on Monday June 26, 2023 @04:25AM (#36477156)
Thanks for your comment, I enjoyed it.

I think the computer industry is in its infancy and we haven't really found the right solution to many problems, for everyone to adopt the same thing requires it to be a very good option. BSD sockets is used by everyone - it's that good.

It reminds me of xkcd #927 about standards ( https://xkcd.com/927/ )

I would like a solution to the problem where library code is changed and it breaks code that relies upon it.

I would also like an API description format that we can code against and doesn't break.

Re:XML Is the Future by AdamCraven on Monday June 26, 2023 @04:40AM (#36477248)
It's because a lot of engineers are learning to become better plumbers, not better engineers.

Trying new technologies means you're mostly becoming better at using someone else's APIs - this is the path to eventual burn out as the churn continues.

There is a better path - See through the hype. Ask those around you what's the downsides to this approach? And you'll often get blank stares... Why? Because they don't know either - And if they don't know the downsides, they don't really know. They are following the hype curve.

Focus on the fundamental engineering principles and asking better questions - take the bottom-up approach and the reward is you'll find teams that aren't taken by the hype curve so easily.

PS. There are a lot of good technologies that come out, but staying behind the hype curve a little helps you make better judgements over time.

Re:XML Is the Future by nigma1337 on Monday June 26, 2023 @05:05AM (#36477415)
I have such a fear for this, that things i invest time/energy into today will be obsolete in half a year, and my time would be essentially "wasted".

As others say, learning the fundamentals will, and trying to get some more general skill out of every tech fad.

(although, full rewrite every 6 months is excessive imo)

Re:XML Is the Future by wofo on Monday June 26, 2023 @06:25AM (#36477890)
Wow, this resonates with me! I stopped doing full-stack development a while ago, and have since January been contributing to open source projects as a contractor (my next gig will be for ISRG, the makers of Let's Encrypt, :D). By working on open-source libraries I get to tackle interesting problems without being bogged down too much by accidental complexity. It feels like the ideal solution to me (though it is difficult to replicate, as it takes quite some luck).
Re:XML Is the Future by DarkCrusader2 on Monday June 26, 2023 @07:26AM (#36478303)
I am in the exact opposite,but equally frustrating boat.

In last 5 years, I have worked at 2 Faang and a large hedge fund and everywhere they had extremely outdated stack or undocumented in-house stack or outdated undocumented in-house stack. Already derecated dependencies were pinned years ago and management won't let you modernize anything since there "no business value in it" and we need to ship a feature instead and if you still insist to refactor and modernize and something goes wrong, now you are personally responsible for the outage. The effort you spent successfully upgrading decades old stack won't count in your promo packet.

There is just no incentive to upgrade anything beyond security fixes. Rewrite to chase the latest fad is frustrating but using technologies which don't even have online documentation anymore is equally if not more frustrating.

Re:XML Is the Future by Quarrelsome on Monday June 26, 2023 @07:44AM (#36478457)
I was stuck maintaining a solution using an abandonware internal transport layer built on technology that died in 2004 and an abandoned ORM on an EAV schema database over SOAP backend in 2022 with much the same "no business value in it" argument. "We're trying to sell the company so profit is of the most importance" transitioned into "we bought you because you make money". So instead we increased our maintenance exposure by adding more necessary features to the wobbly pile (or 'fixing' broken ones) as opposed to resolving the mistakes made over twenty years ago.

Of course the dickhead architect would use articles like this OP as justification for why all of this wasn't a problem.

Re:XML Is the Future by mathgeek on Monday June 26, 2023 @07:54AM (#36478531)
Today’s beloved tech with well maintained docs is tomorrow’s institutional knowledge tech that companies rely on.
Re:XML Is the Future by pdimitar on Monday June 26, 2023 @12:45PM (#36482216)
Not my observation sadly. We've got some excellent 10+ years old tech -- Golang, Rust, Elixir -- yet a lot of companies out there holds on to C#, PHP and Java with an death grip.

And I've worked with all of these. The newer stuff is better in every way except penetration (which is held back by bias and misguided evaluations of the word "safe").

Re:XML Is the Future by oblio on Monday June 26, 2023 @06:38PM (#36486808)
I wouldn't put C# and Java in the same pile with PHP as bad tech and Go against them as good tech.
Re:XML Is the Future by pdimitar on Tuesday June 27, 2023 @07:52AM (#36491580)
I would, when it comes to parallelism. Java being stuck at OS threads (I know about Loom but it's nowhere near the BEAM VM or goroutines) is not doing it any favors.

PHP at least attempted some isolation between requests (emphasis on attempted) even though it didn't do it very well.

All that being said, people don't like seeing their favorite tech called out and the kneejerk down arrow presses are expected. Programmers are a tribal bunch.

Personally I've found my productivity multiplied with the above-mentioned more modern tech: Elixir, Rust and Golang. But I am also aware many companies would never risk it, and that there is no shortage of people who are OK coasting on old stacks if it pays the bills. Not judging.

Re:XML Is the Future by goodpoint on Monday June 26, 2023 @07:58AM (#36478570)
Maintaining old stuff is way more sensible than rewriting everything every few years.
Re:XML Is the Future by Cthulhu_ on Monday June 26, 2023 @08:13AM (#36478690)
Up to a point, there's always a tradeoff and a turnover point; at the moment the old Cobol mainframes are one of those; the tradeoff is that there's a lot of institutional knowledge and essential processes in that code, but on the other it's harder to find competend staff that can - and want - to work with it.
Re:XML Is the Future by WJW on Monday June 26, 2023 @09:05AM (#36479211)
Sensible for who? Companies may try to estimate costs of maintenance vs rewrite, but individuals need to make the final call and for them the benefits usually go the other way.

Maintaining some existing project is going to get you nothing if you do it right and will bring you problems if it breaks despite your best efforts. Rewriting an existing system in a new tech stack counts as exciting innovative work for promotion purposes, or at least prepares your CV for your next job hop. With salary bumps between levels being what they are in software, I'm not surprised people choose the more lucrative option.

Re:XML Is the Future by datavirtue on Tuesday June 27, 2023 @10:05AM (#36492965)
A stack that goes down all the time is a ripe opportunity for career advancement, if you are in to that.

Hell, I have seen the creators of the problems get endlessly promoted for constantly solving problems they created.

Small or medium company, critical systems going down a lot...give me that shit. Easy money and reputation.

Re:XML Is the Future by Cthulhu_ on Monday June 26, 2023 @08:11AM (#36478682)
It's a weird tradeoff between innovation vs reliability, investments vs cost, but also, staff retention & hiring. I think a lot of companies follow fads as a way to attract talent. It's not in their best interest to follow the fads or spend time rebuilding the same thing over and over, but otherwise they'd run out of competent staff and are left with low energy / "safe" developers.
Re:XML Is the Future by grugagag on Monday June 26, 2023 @09:49AM (#36479637)
Competent staff = magpie devs?
Re:XML Is the Future by dicroce on Monday June 26, 2023 @08:18AM (#36478737)
The way that I have avoided burnout for all these years is working on my own projects, and building them exactly the way I want to. This gives me the strength to grind through the shitty work I am paid to do.
Re:XML Is the Future by fnord77 on Monday June 26, 2023 @08:48AM (#36479053)
really surprised faang management doesn't see the value in addressing technical debt.
Re:XML Is the Future by grugagag on Monday June 26, 2023 @09:51AM (#36479656)
Move fast and break things has downsides that get to be paid some years down the road.
Re:XML Is the Future by ncphil on Monday June 26, 2023 @10:31AM (#36480079)
Because they don't see technical debt as a bad thing. Go back to the original pitch for technical debt by Ward Cunningham. He was working for a finance company and used the debt metaphor to advocate in favor of "borrowing against the future" when implementing new code. The idea was that you could use the latest stuff without reinventing everything. Like mortgage payments, the reinvention could happen over time, in increments, until it's "paid off". The problem is that nowadays, especially in finance, you're dealing with people who are used to over leveraging everything. To them, the idea is to pile on debt until it becomes unmanageable: and then sell. Or go into Chapter 11.
Re:XML Is the Future by deterministic on Tuesday June 27, 2023 @02:38AM (#36489607)
Rewriting an application will usually simply give you a more buggy app with less features and more technical dept. At a high cost.

Smart businesses and developers instead step-by-step refactor and upgrade their existing apps.

Re:XML Is the Future by fifticon on Monday June 26, 2023 @09:15AM (#36479307)
news flash: You are working in exactly the same place.. it is just 5 years later :-) All that outdated technology you mention, was probably introduced as the newest-cant-live-without at some earlier time.
Re:XML Is the Future by throwuwu on Monday June 26, 2023 @09:26AM (#36479408)
So how old does the tech need to be?
Re:XML Is the Future by grugagag on Monday June 26, 2023 @09:48AM (#36479624)
It doesn’t matter as long as it is consistent and maintained.
Re:XML Is the Future by falcolas on Monday June 26, 2023 @09:49AM (#36479639)
I’d say at least 5 years since it’s debut.

Long enough for the rough edges to be softened, to show that people are willing to maintain it, for detractors to have pointed out legitimate issues, for the tech to become stable.

I’d prefer 10 years personally, but I value stability more than most. I dislike revisiting problems I’ve already solved.

Re:XML Is the Future by 6510 on Monday June 26, 2023 @10:00AM (#36479742)
The hype train never stops! The golden ticket is for the front cabin but ideally you are driving it.
Re:XML Is the Future by dusted on Monday June 26, 2023 @10:06AM (#36479803)
The older the better.

The better understood, both in capability and limitation.

The better chance no new updates will break it.

The better chance no new updates.

The better you get to know it.

The better you get to integrate it.

The better the chance it will be there tomorrow too.

The better the investment learning it becomes.

Re:XML Is the Future by mablopoule on Monday June 26, 2023 @10:42AM (#36480235)
On the opposite end of the spectrum, if your stack is too old (and niche enough) then you won't get to know it very well once every bit of documentation was hosted on expired domain name, and you can only find bits of online discussion about it are Internet Archives snapshots of a forum long since dead.

And also you don't get to integrate it very well if everything around it isn't maintained, and compatible on old version of a library (with said documentation not existing anymore).

Also, while resume-driven development is not a good thing either, it's certainly not a good investment to pigeonhole your career into working with something you hate working with.

Re:XML Is the Future by noisy_boy on Monday June 26, 2023 @11:08AM (#36480614)
> The older the better.

But remember to use the right tool for the right job - older isn't always better. E.g. there is a set of people who use stored procedures for everything and it does make sense when you are doing data-heavy processing on database-side. But using that for everything, even when the volume is absurdly low, is a bad idea - using a language like Java would be a million time more flexible, composable, testable (unit tests, anyone?) and allow making changes with greater confidence.

Re:XML Is the Future by datavirtue on Tuesday June 27, 2023 @09:51AM (#36492764)
PHP old
Re:XML Is the Future by 6510 on Monday June 26, 2023 @09:43AM (#36479580)
Sounds like such a place could have really nice documentation.
Re:XML Is the Future by manvillej on Monday June 26, 2023 @02:51PM (#36484083)
In both of your cases, I think there is this massive disconnect in decision making. Software development is a constant game of economic decision making. Which investment returns the greatest value. Agile worked because it spread risk and allowed for reaction to new opportunities.

CICD/devops worked because it drastically reduced the risk & expense of defects, the cost of development, time to market, etc.

But the chasing of new technology fads vs lagging behind with old outdated technologies? I am seeing people make decisions without thinking about the decision.

What economic benefit does the new tech bring? Whats the economic trade off of implementing it vs other projects? How long till a return on investment? Whats the costs if we do nothing?

It isn't even that hard to do, but people just keep deciding to spend time and resources with little to no thought. It infuriates me.

Re:XML Is the Future by namaria on Tuesday June 27, 2023 @04:52AM (#36490485)
If the way people allocate resources makes no sense, you are likely missing information on the returns they're getting from it.
Re:XML Is the Future by datavirtue on Tuesday June 27, 2023 @09:59AM (#36492881)
"Agile worked"

Citation needed.

Re:XML Is the Future by gofreddygo on Tuesday June 27, 2023 @03:04PM (#36497288)
The decision makers themselves are couchsurfing.

You'll consistently notice obviously idiotic decisions rooted at decision makers who aren't around to own up to the mistake.

The other end has decision makers never change, they waited too long, were too risk averse to stagnate and the cost of change just keeps rising.

The ones who end up surviving this churn, have both kinds of decision makers in equal powers, mistakes are made, but things keep moving sometimes in leaps, sometimes backward steps.

Re:XML Is the Future by deterministic on Tuesday June 27, 2023 @02:33AM (#36489577)
Congratulations. It sounds as if you are working for a company that knows what it is doing. They are clearly focusing on customer value instead of chasing the latest shiny new but buggy and gone tomorrow “new” tech. Giving you an opportunity to focus on delivering value to customers in a stable environment. Making each delivery higher quality and less buggy than the previous.

I work in such an environment and routinely deliver million+ line applications with ZERO bugs in production to very large customers around the world. Highly satisfying.

Re:XML Is the Future by Waterluvian on Monday June 26, 2023 @07:32AM (#36478345)
After a decade I think I’ve concluded for myself that this is, for the most part, a self-inflicted problem. There’s really no need to keep refactoring or feel like others need to stop inventing new ways of doing things.
Re:XML Is the Future by lumb63 on Monday June 26, 2023 @08:00AM (#36478587)
Have you ever considered a different portion of the tech sector? I work in embedded systems and this couldn’t be further from the truth. Things rarely change (because it took someone smart banging their head against a wall for a week to make it work) and if they do, they’re usually addressing real needs in the systems programming community. I see each change less as a fad and more as an additional tool in the tool belt.

Take for example Rust, which is gaining traction in parts of systems programming. It addresses the direct need to stop overflowing buffers, create more strong typing, write less code to accomplish the same thing, and others. Accordingly, a lot of systems programmers are optimistic and excited about it. But everyone in the field knows C, and acknowledges C isn’t going anywhere. There are tasks for which C is better suited right now, and will be for a very long time. There’s no push to rewrite all programs in Rust. Sure, some are pushing for it, but it’s not a “this year is Rust, next year is <new programming language>” dynamic. It’s a “this is where we want to go, but it’s going to take us many years to get there” type shift.

Re:XML Is the Future by otabdeveloper4 on Monday June 26, 2023 @08:12AM (#36478689)
Be thankful there are still people willing to pay you for bullshit jobs.

Things will be tougher when management starts asking for real, measurable results.

Re:XML Is the Future by ed25519FUUU on Monday June 26, 2023 @08:47AM (#36479043)
Gotta make hay while the sun is shining.
Re:XML Is the Future by BeFlatXIII on Monday June 26, 2023 @11:12AM (#36480683)
Perhaps that would be the time to transition into playing rainmaker.
Re:XML Is the Future by commandlinefan on Monday June 26, 2023 @09:26AM (#36479407)
> Hype after hype, fad after fad, modern after modern, refactor after refactor

And you're supposed to already know how to do it and give an accurate ~~estimate~~ prediction for how long it's going to take to do (that matches the amount of time they've already decided you have to do it). You're a _professional_ and professionals don't need time to actually learn how to do something new, they just know.

Re:XML Is the Future by exhuma on Monday June 26, 2023 @10:58AM (#36480436)
I've been in the industry for over 30 years and I absolutely get where you're coming from. It is an ever changing field and it can be exhausting. I hear this repeatedly from many coworkers (and workers from the same field).

All I can give is some advice from my lengthy experience.

Most of the changes happen on the "edges". Those edges are primarily three fold:

First, the user interface: everything that deals with input parsing and formatting. This also includes protocol marshalling (Http, JSON, XML, ...)

Second the data persistence. This involves choice of database or any other persistence. Including serialisation of your data. Any I/O really.

Third, anything to do with deployment. This includes environment isolation, configuration management, process automation and so on.

These the edges have nothing to do with your core application logic.

You can reduce the impact of a switch to a new stack by inflating your core logic and shielding it from the rest of your stack.

This is tricky and I still catch myself all the time doing it wrong. Because doing it wrong is tempting and easy.

For example, consider a connection to the db: you will need a connection string. You can fetch that from an environment variable somewhere deep in your core code. But by reaching out to the system like that, you make that core piece of code dependent on the deployment strategy. Instead, you can move that part as close as possible to the entry point and then pass it down as function/class arguments. You can group similar operations together, close to the entry point. That way, if the dependent e strategy or the stack changes, your core code does not need to change.

Another example is the case where your core code is dependent on a library from your stack. For example, when working with python and flask, it's easy to import "request" or "g" from the framework. But every piece of code relying on that will be tightly coupled to the framework and subject to change whenever the framework changes (either same framework with breaking changes, or framework switch). The solution is the same. Move those elements as close as possible to the entry points. In this example of flask, keep this as close as possible to your routes. But also keep your routes clean of core logic. Interact with the HTTP layer only and pass the values as arguments to your core.

Finally, a similar situation, but much more sneaky and hard to spot is reliance on data types from your stack. Spotting cases where you rely too much on library modules can be done by investigating imports. But reliance on data types is harder to spot. Sticking with the flask example: the http headers are encapsulated by an object of the flask stack (werkzeug in this case). You may be careful and extract the headers in the route to follow my earlier example. But if you then pass the headers unmodified down into your core logic you will again be coupled to the stack. Instead you should extract only the values you care about and hand only those down to break the coupling.

Finding the right balance where to cut the coupling is challenging. The more you cut, the better you will be shielded from changes. But the less you can benefit from pre existing implementations from the stack. Where to cut is ultimately a design decision.

When done well, it will be far less frustrating to jump on the bandwagon of the latest tech. Not completely painless but far less stressful. Not least because you will have confidence that you didn't accidentally break core logic.

Re:XML Is the Future by Hermitian909 on Monday June 26, 2023 @12:22PM (#36481858)
I have a partial solution to this I'm happy pretty happy with.

First, is that I dove farther into CS fundamentals. This has made new fads a lot easier to deal with because usually they're recycling old CS ideas. React hooks is a good example. I wrote class components for many years, adopting to hooks took me all of a day because Algebraic effects were something I understood well.

Second - I am firm about which tech I do and do not want to learn the specifics of. I understand the high level of kubernetes but will not be learning specifics.

Re:XML Is the Future by red-iron-pine on Monday June 26, 2023 @03:06PM (#36484318)
> We just keep changing and changing the same things again and again because that's the new way to do

Capitalism doesn't work unless you have something to sell, and that's just as true for tech as it is anywhere else.

Re:XML Is the Future by cyanydeez on Tuesday June 27, 2023 @07:27AM (#36491412)
My man's ear never heard of corporate growth culture