Just because you won't use it doesn't mean it's not useful. Lots of programmers use math. Lots of programmers use DSA knowledge on a daily basis - and if you aren't you're probably writing bad code. I see a lot of O(n^2) code or worse making apps slow for no reason. Pretty basic stuff that most people don't understand despite taking a whole class on it.
Sure I learned lots of stuff I've never used. Like relational algebra. But I also learned lots of stuff I use a lot, and it's unlikely I'd have studied most of that stuff on my own. During my degree I also had time and opportunity to pursue lots of other topics outside the mandated course material, you're not limited to what they force you to learn.
So sure if you have the motivation, discipline and resourcefulness to learn all that stuff on your own go right ahead. Most people aren't even close. Most people are much better off with a degree.
You know there's a lot of places in this world where education is pretty much free. Turns out it's good for society when people do well, and most first world countries have figured that out and leaned into the whole helping each other thing. We even get to be sick or injured without losing our job and getting a $100,000 bill, it's crazy.
I think free education is fantastic for society and would vote for that every time, taxes be damned.
But until then we in the US live in a capitalist hellscape where we have to prioritize survival which means only focusing on marketable skills to get a job. After that one can pay for college once they can afford it if they want that experience for personal enrichment.
> Lots of programmers use DSA knowledge on a daily basis - and if you aren't you're probably writing bad code. I see a lot of O(n^2) code or worse making apps slow for no reason
I don't think one can seriously argue that. This as much a meme as anything. I know it's popular to rag on devs writing inefficient software, but there's plenty of apps with functions where a user couldn't possibly notice the difference between O(n^2) and O(1). You wouldn't take the time to make everything O(1) for no speedup because someone told you that's what good code is, that's just wasting dev time.
In fact, one of the first things you learn is that O(1) can be slower. Constant time is not good if the constant is big and n is small.
Obviously I'm not talking about the cases where it doesn't matter. I'm talking about the cases where it does.
I fixed one where a report took 25 minutes to generate and after switching out an O(n^2) list lookup with a dict it too less than 5. Still embarrassingly slow but a lot better.
There's also a lot of cases where it didn't matter when the dev wrote it and they had 400 rows in the db but 5 years later theres a lot more rows so now it matters.
Doesn't cost anything to just use a better algorithm. Usually takes exactly the same amount of time, and even if it is marginally slower at small n values who cares? I don't give a shit about saving nanoseconds. I care about the exponential timewaste that happens when you don't consider what happens when the input grows.
For small inputs it doesn't matter what you do. Everything is fast when the input is small. That's why it makes sense to prefer low complexity by default.
The first thing that comes to mind is one time when I was pretty drunk, in my late teens, hurt my legs trying a very ambitious(stupid) jump and then passed out at a bus stop. Woke up later, no phone battery, in the city about an hour away from home and nobody else I knew around.
Limped into a 24hr kiosk and asked to borrow their phone to call for a ride. Got a no. Tried explaining the situation, no sympathy.
A guy who happened to be in there saw that I was really not having a great time, came over and just hugged me and said it was gonna be alright and let me use his phone. No idea who you are, wouldn't recognize you if I ever met you again, but thanks for that.
I kind of struggle with this. I basically hate everyone elses code, and by that I mean I hate most people's code. A lot of people write awesome code but most people write what I'd call trash code.
And I do think there's more to it than preference. Like there's actual bugs in the code, it's confusing and because it's confusing there's more bugs. It's solving a simple problem but doing so in an unnecessarily convoluted way. I can solve the same problem in a much simpler way. But because everything is like this I can't just fix it, there's layers and layers of this convolution that can't just be fixed and of course there's no proper decoupling etc so a refactor is kind of all or nothing. If you start it's like pulling on a thread and everything just unravels.
This is going to sound pompous and terrible but honestly some times I feel like I'm too much better than other developers. I have a hard time collaborating because the only thing I really want to do with other people's code is delete it and rewrite it. I can't fix it because it isn't fixable, it's just trash. I wish they would have talked to me before writing it, I could have helped then.
Obviously in order to function in a professional environment i have to suppress this stuff and just let the code be ass but it really irks me. Especially if I need to build on something someone else made - itsalmost always ass, I don't want to build on a crooked foundation. I want to fix the foundation so the rest of the building can be good too. But there's no time and it's exhausting fixing everyone else's messes all the time.
I can guarantee you that if you were to write a completely new program and continued to work on it for more than 5 years, you'd feel the same things about your own code eventually. It's just unavoidable at some point. The only thing left then is degrees badness. And nothing is more humbling than realizing that the only person that got you there is yourself.
No, I wouldn't. I have been working for years on the same codebase, it's not that hard to keep it clean and simple. I just refactor/redesign when necessary instead of adding hacky workarounds on top of hacky workarounds for years until the codebase is nothing but a collection of workarounds.
And most importantly I just design it well from the start, it's not that hard to do. At least for me.
Of course we all make mistake, there's bugs in my code too. I have made choices I regret. But not on the level that I'm talking about.
I can guarantee you that I have been doing just that for 20 years, creating and working on the same codebase, and that it only got better with time (cleaner code and more robust execution), though more complex because the domain itself did.
We would have been stuck in the accidental complexity of messy hacks and their buggy side effects if we had not continuously adapted and improved things.
I feel this too. And it seems like the very worst code always seems to come from the people that seem the smartest, otherwise. I've worked for a couple of people that are either ACM alum and/or have their own wikipedia page, multiple patents to their name and leaders in business, and beyond anyone else that I have ever worked with, their code has been the worst.
Which is part of what I find so motivating with AI. It is much better at making sense of that muck, and with some guidance it can churn out code very quickly with a high degree of readability.
I don't know how a "good" programmer opens the same gig+ file for writing in multiple threads (dozens sometimes) without any kind of concurrency management.
A "good" programmer doesn't give you a 2000+-line python script where every variable has no more than two characters in its name, with 0 comments or explanatory info.
A "good" programmer doesn't write a cluster that checks an "OK" REST endpoint on a regular interval, and then have that same cluster freak the fuck out and check 10-100x as often if that "OK" does not arrive exactly as it should.
I usually attribute it to people being lazy, not caring, or not using their brain.
It's quite frustrating when something is *so obviously* wrong, to the point that anyone with a modicum of experience should be able to realize that what was implemented is totally whack. Please, spend at least a few minutes reviewing your work so that I don't have to waste my time on nonsense.
Yeah a bridge has a plan that it’s built and verified against. It’s the picture book waterfall implementation. The software industry has moved away from this approach because software is not like bridges.
One of my better experiences with software development was actually with something waterfall-adjacent. The people I was developing software for produced a 50 page spec ahead of any code being written.
That let me get a complete picture of the business domain. That let me point out parts of the spec that were just wrong in regards to the domain model and also things that could be simplified. Implementation became way more straightforwards and I still opted for a more iterative approach than just one deliverable at the end. About 75% of the spec got build and 25% was found to be not necessary, it was a massive success - on time and with fewer bugs than your typical 2 week "we don't know the big picture" slop that's easy to get into with indecisive clients.
Obviously it wasn't "proper" waterfall and it also didn't try to do a bunch of "agile" Scrum ceremonies but borrowed whatever I found useful. Getting a complete spec of the business needs and domain and desired functionality (especially one without prescriptive bullshit like pixel perfect wireframes and API docs written by people that won't write the API) was really good.
If you can't get a complete spec, it's better start with something small that you can get detailed info on, and then iterate upon that. It will involve refactoring, but that is better than badly designing the whole thing from the get go.
I enjoyed that but honestly it kind of doesn't really resonate. Because it's like "This stuff is really complicated and nobody knows how anything works etc and that's why everything is shit".
I'm talking about simple stuff that people just can't do right. Not complex stuff. Like imagine some perfect little example code on the react docs or whatever, good code. Exemplary code. Trivial code that does a simple little thing. Now imagine some idiot wrote code to do exactly the same thing but made it 8 times longer and incredibly convoluted for absolutely no reason and that's basically what most "developers" do. Everyone's a bunch of stupid amateurs who can't do simple stuff right, that's my problem. It's not understandable, it's not justifiable, it's not trading off quality for speed. It's stupidity, ignorance and lazyness.
That's why we have coding interviews that are basically "write fizzbuzz while we watch" and when I solve their trivial task easily everyone acts like I'm Jesus because most of my peers can't fucking code. Like literally I have colleagues with years of experience who are barely at a first year CS level. They don't know the basics of the language they've been working with for years. They're amateurs.
Then it’s quite possible that you’re working in an environment that naturally leads to people like that getting hired. If that’s something you see repeatedly, then the environment isn’t a good fit for you and you aren’t a good fit for it. So you’d be better served by finding a place where the standards are as high as you want, from the very first moment in the hiring process.
Obviously that’s easier said than done but there are quite a few orgs out there like that. If everyone around you doesn’t care about something or can’t do it, it’s probably a systemic problem with the environment.
Have you considered the possibility that 401ks and pension funds etc are included in those numbers?
Open for the elite in the way that everyone else don't have enough money to matter.
The richest people are so much richer than everyone else that there's no comparison. You could grab a million average people off the street and all of you combined probably wouldn't be richer than Jeff Bezos. Think about that. This one guy is wealthier than a million other people combined, literally wealthier than an entire small country or large city, and he's not alone. There's more of them.
Those guys rule the world, everyone else are passengers.
How about 12,000 years of overlapping ring patterns from paleo trees?
Live trees, dead trees in buildings, bogs, tidal zones, etc.
There's also sedimentation layers from multiple scattered bore samples that will reveal more about patterns of particle fall from the skies and layered flows from years past.
This particular fact somewhat undercuts your strong assertion:
> Not a chance.
as there are actual well documented trees in the region that do form annual rings. The Afar isn't solely vegetated by Dracaena ombet which lack annual rings.
> This particular fact somewhat undercuts your strong assertion:
My strong assertion, was not "there are no trees". Of course there are some trees of some size in some places. Not the same as an oak forest, but still.
My strong assertion was regarding how very unlikely "12,000 years of overlapping ring patterns" would be from the sparser and smaller and less long-lived vegetation.
You might want to look deeper into the links I provided re: dendrochronology.
There's no necessity for 12K years of volcano adjacent tree ring sources, any more than there's a requirement that the current immediate vicinity have many trees.
I can leave that for you to ponder, it's not hard to fathom why.
The scope of volcano eruption also comes into play, of course, there's a bunch of papers about tree rings and evidence of volcanic eruption wrt: The Black Death (1347 - 1353) in Europe with a wide separation between volcano and tree ring sites.
The Tanami's tough country, it's where the last people (known) to first encounter "western" civilisation walked out from. It's where several of them returned after a few years of exposure.( https://www.bbc.com/news/magazine-30500591 )
Do you have any stories of your time in the Ethiopian Afar that provide first hand field experience for your strong assertion?
Getachew Eshete and Göran Ståhl did some work there in 1999 in the Rift Valley part of the Afar region that indicated Acacia growth rings can be used as climate indicators for the 30 year life span periods of the wood studied.
I specifically meant live trees, didn't really occur to me that dead trees could be relevant. Not sure how common it is to find 12000 year old dead trees either but I guess it's more common than live ones.
And of course geological surveys would definitely tell you something about the past
The real problem with tree rings here in this specific case is ... Ethiopia .. not a lot of big trees now, nor in the recent past when it was grasslands - but not really my field - there's likely to be very slow growing unassuming trees that are surprisingly old there .. and remains of older trees that have overlapping ring sequences.
But yes - geological / geophysical clues are likely more relevant here.
This is such a crappy point. People say it's better now but even in java 8 it's just BS. Oh boo hoo I have to write a few extra words here and there. Woe is me. The IDE will autogenerate the boilerplate for you, you don't even have to write it yourself. And once it's there it's actually useful, there's a reason it exists.
Seriously. I don’t get all the over concern over the verbosity. At least in java you can tell what the hell is going on. And the tools…so good. Right now I am in python typescript world. And let me tell you, the productivity and ease of java and c# are sorely missed!
Sounds like cope. Great Type System, Language Server, IDE Integration, compiler feedback, tooling ecosystem, DX Hot Reload - all things that made it the most used programming language on GitHub.
Overcomplicated type system. Language server seems redundant to mention, everything has a language server. Everything has ide integration. Everything has decent compiler feedback. Everything has hot reloading.
Pretty much all major languages have all of those features save hot-reloading, but that only even makes sense for UI written in an interpreted language.
Being able to update the code while it's running is useful for all kinds of use cases. Desktop apps, web apis, server side rendered web apps, .net blazor apps, etc.
It's nice to be able to see what your changes do without rebuild and restart.
Is this what we are reduced to now, to snap back with a wannabe-witty remark just because you don't like how an idea sounds? Have we completely forgotten and given up on good-faith scientific discourse? Even on HN?
I'm happy to participate in good faith discourse but honestly the idea that LLMs are conscious is ridiculous.
We are talking about a computer program. It does nothing until it is invoked with an input and then it produces a deterministic output unless provided a random component to prevent determinism.
That's all it does. It does not live a life of its own between invocations. It does not have a will of its own. Of course it isn't conscious lol how could anyone possibly believe it's conscious? It's an illusion. Don't be fooled.
Reading what you said literally, you're making a strong statement that an AI could never be conscious and further that consciousness depends on free will and that free will is incompatible with determinism and that all of these statements are obviously self-evident.
Sure I learned lots of stuff I've never used. Like relational algebra. But I also learned lots of stuff I use a lot, and it's unlikely I'd have studied most of that stuff on my own. During my degree I also had time and opportunity to pursue lots of other topics outside the mandated course material, you're not limited to what they force you to learn.
So sure if you have the motivation, discipline and resourcefulness to learn all that stuff on your own go right ahead. Most people aren't even close. Most people are much better off with a degree.
reply