Welcome to the main community in programming.dev! Feel free to post anything relating to programming here!
Cross posting is strongly encouraged in the instance. If you feel your post or another person's post makes sense in another community cross post into it.
Hope you enjoy the instance!
Rules
Follow the wormhole through a path of communities !webdev@programming.dev
That programming as a career means you're going to spend writing nice, clean code 80% of the time.
It's rather debugging code or tooling problems 50% of the time, talking to other people (whether necessary or not) about 35% of the time and the rest may be spent on actually spending time doing the thing you actually enjoy.
I may be exaggerating, but only a little.
In my experience, you're rather inaggerating. I'm not even 10y into my career and if I get to actually code for 2h a day, that's already a success. Most of my time nowadays is documentation, meetings, jira, research and calls with the clients.
I think it heavily depends on the size and (management) culture of your employer. My most recent gig had me sit in way too many meetings that were way too long (1hr daily anyone?), dealing with a lot of tooling issues and touching legacy code as little as possible while still adding new features to our main product on a daily basis. Obviously "we don't need a clean solution. We're going to replace that codebase anyways, next year™".
The job before that had me actually code for about 80% of the time, but writing tests is annoying and slows you down and we don't have time for that. Odd how there was always time for fixing the regressions later.
I think it's also a question of how you position yourself. Without noticing it, I've developed a kind of "will to power" in the sense that I want to shape the product we're working on. So instead of just sitting in my corner and working on ticket after ticket, I'm actively seeking conversations with stakeholders to find out, whether it even makes sense to implement it as described in the ticket, or propose new ideas, etc.
Also, my mother taught me (by virtue of being completely untechnical) how to explain complex problems and systems in a way that non-technical people understand. So if "a developer" was needed, management often enough volunteered me.
I could pull myself mostly out of this stuff, but I'd get even more frustrated not being able to at least try to make things a bit better. So I'm putting on the headset once more.
"We're going to clean up that code later."
That you can just go to a bootcamp, and be good at or naturally suited for it.
That you can go to college and get a degree, and be good at or naturally suited for it.
"Programming is just writing code"
Programming is, first and foremost, understanding what the fuck you want/need the computer to do. That means that some programmers (mostly analysts) may understand workflows and processes better than the people whose job depends on their knowledge of said things.
People don't realize that as you get better at programming, the amount of code you write goes down. At least in my experience, my work day has shifted to 80% thinking about what I'm going to write and then about 20% actually writing it.
1 hour of planning can save 10 hours of work.
1 hour of research can save 10 hours of planning.
This one's a hot take, but: That Python is easy.
I've had to work with it in three projects in the past five years and I consider it one of the hardest programming languages, for anything but very short scripts.
You don't get proper compiler assistance, unless you have 100% test coverage. You don't get a helpful text editor. You don't usually get helpful type hints in libraries you use, so you have to genuinely just study the documentation and/or code. You get tons of quirky behavior in the stdlib, build tools, async stack, imports. You get breaking changes in minor versions of the language.
I find writing code in Python extremely mentally taxing, because you just get so little assistance, that you have to think of everything yourself.
I think Python is easy to learn but difficult to get past the basics. I'm also not convinced that getting past the basics is even worth it in three long run. I say this as a person who has used all Python at work for roughly 70 percent of the last 15 years. My current position is moving to Rust and my last 2 positions were moving to Go. Everybody was happier.
Dynamically typed languages all suffer that fate. There's a reason Typescript literally has that feature in its name.
What does help though is type hinting. You "just" have to enforce it and its fallout in your entire codebase.
Yeah, we invested a lot of time into type hinting and checking, but mypy would never exit without warnings and errors, because many libraries we were using had no type hints.
It was also just exhausting/cumbersome, having to write type hints everywhere, as there's no type inference.
But yeah, we always joked that someone should create TypeScript for Python – Typhon.
Try the PyCharm IDE. It's really smart and helpful. The free 'community edition' is fine.
I'm sorry to say this, but PyCharm is precisely what we were using. I do consider it the best Python editor, but it's several classes below IntelliJ for Java/Scala/Kotlin or even the extremely new RustRover for, well, Rust. And I'd say roughly at the level of KATE (a non-smart text editor) with just the rust-analyzer language server hooked up.
It is extremely impressive what PyCharm manages to analyze in Python, but other languages offer similarly good tooling out of the box, or make such analysis much easier by having static types.
I don't know if i qualify as a full programmer, I'm an actuarie but 90% of my work is in python, 5% SQL and 5% excel. I love python because is flexible as fuck, I can connect to the SQL server, send the queries to a pd.DataFrame, process the information, scrap some webpage for adicional information needed, and finally export to an excel file that the accounting team can use. I don't write fully functional programs, but small specific scripts for different tasks. R is another popular programming language between actuaries and statisticians, but I haven't find anything that R can do, that I can't in python.
I don’t write fully functional programs, but small specific scripts for different tasks.
This is exactly why your experience is different and you like Python better than many others. You are using Python as it was meant to be used and where it excels; for small scripts.
When people say they don't like Python they mean that Python does a really, really bad job when it comes to larger systems. Static analysis becomes exponentially more important in larger systems and Python has basically 0 of that.
But as long as you stick to relatively small stuff (less than a few thousand lines), Python is pretty nice and fast to develop in.
That if you know how to code, you understand how computers work and understand really complicated math concepts.
I call that the "nerd equivalency problem". I think it's the source of much (most? all?) of the problems with software that comes out of organizations that are not programming shops by nature.
"We're not moving fast enough (or, "I have this great idea!"), hire another nerd!"
The problem also exists within individual programmers ("sure, I can do that UX/UI thingy, just let me finish building this ray-tracing thingy"), but that's just an ordinary cognitive weakness that affects us all (thinking that being expert in one field makes one expert in all). It's the job of proper leadership to resist that, not act as though it's true.
Technical Leads are not rational beings and lots of software is developed from an emotional stand point.
Engineering is trade offs, every technical decision you make has a pro/con.
What you should do is write out the core requirements/constraints.Then you weigh the choices to select the option that best meets it.
What actually happens is someone really likes X framework, Y programming language or Z methodology and so decides the solution and then looks for reasons to justify it.
Currently the obvious tell is if they pitch Rust. I am not saying Rust is bad, but you'll notice they will extoll the memory safety or performance and forget about the actual requirements of the project.
I know they make a joke about Tom in office space being the one who brings the specs from the customers to the engineers - as much as it looks like he's dead weight, there really is a skill in being able to explore the customer's needs (and frequently manage their expectations of what the proposed software should be and do) and parse them into something more technical for the engineers, because you might not know how to program, but you've got a good idea of what the capabilities are because you communicate with the engineering team on a daily basis.
That a "working" prototype with no tests is just as good as a carefully-designed and well-tested feature. I see this happen so often that a coder puts a prototype in front of a product manager or exec and they are like, "this is exactly what we need, now! Ship that!" And then misery ensues for all of the engineers that need to maintain this piece of garbage. As managers pressure the engineers to build new features on top, they inevitably break fundamental parts of it, and without a confident leader to demand that tech debt is paid off, that product will consume the souls of many desperate coders.
In contrast, if you do it right the first time, there will be significant parts of code that never need to change, and the parts that do need to change will be much easier, because it will be obvious if it breaks the tests.
That sounds super familiar :D
Anyway, a prototype is not a bad thing, if the managers know the difference. It's easier said than done to "do it right the first time" if you don't know how / what to build. Prototypes can be built to validate hypotheses and generally figure out what works, then build the real thing afterwards.
Yea I should have clarified. Prototypes are a great idea. The problem occurs when you say, "this is good enough we can improve on it as we go." Yea good luck balancing priorities when everything breaks from tapping your keyboard too hard. You MUST NOT MERGE the prototype.
Requiring a candidate to know a specific programming language is stupid. Nearly all of the commonly used languages in industry are similar.
It's maybe more valuable to require knowledge in a specific framework, where knowledge is less transferrable between popular frameworks. Nonetheless, I personally rather hire an engineer that solves problems and learns flexibly rather than one that happens to know the right tech.
Thar just because you solved a particular problem in 10min, all other problems are going to take 10min too.
No programming language, development philosophy, or technology can save you from projects and business lacking clarity. Your ability to communicate and be understood is as/perhaps more important than the quality of your ideas. Consistency is better than perfection.
The misconception that we’re the person to go to to fix your printer…
..I mean we probably can fix it, but it’s a waste of our time…
10% of my ability to fix your computer is because I know the issue
90% is that I don't panic at error messages and I know how to use a search engine
Some programmers are software engineers. They solve problems, sometimes problems with great ambiguity or non-straightforward solutions.
And some programmers are... code technicians? They understand and write code, but their job seldom involves problem solving. Often times, they're asked to code an already solved problem, or mostly solved.
This is not a diss. I was in the second camp for a while. But it hurts your career to stay in that. So be careful.
This one might be a bit controversial, but has rung true in my general experience. Probably a lot of exceptions to these rules, but here goes:
You don't really know a programming language until you understand a fair amount of the standard library and how packages/modules/dependencies work. Syntax is pretty easy, and any mainstream language will work just fine for solving basic leet-code style problems. But when you really spend a lot of time working with a language, you're going to spend more time learning about common libraries and how to manage dependencies. If you're working with a language like C++ or Java, this could also include build systems and how to use them.
Another precursor to being able to say that you know a language is that you should also be familiar with best practices (ie. how to name modules, how to write documentation, etc.) and common pitfalls (undefined behavior, etc.). This is one of the hardest parts about learning a new language in my opinion, because the language may not necessarily enforce these things, but doing them the wrong way can make your life very difficult.
That “just changing a word” is easy and quick. A codebase is an iceberg. Management only really typically understands the surface, but there is a disproportionate amount of ice under the water.
I had to change all instances of a label from a word to an abbreviation. Because we don’t have i18n set up in the app, it ended up affecting 55 different files. I did my best to consolidate into everything calling a common function, but it’s far from perfect. 55 files changed because management said “oh this word here should be shorter”.
that doing more work, takes more time.
Gamers are especially guilty of this.
"that 2013 game runs at a smooth 60 fps. This medern game running at quadruple the resolution with raytracing sometimes dips to 58 fps on the same hardware. Devs must be lazy, they just need to add OPTIMIZATION to the game
When you release something, your work is not done. You have to maintain it, fix bugs, release patches, and probably the worst part, keeping it up to date.
For example, Apple decides to deprecate some API, or decides to switch cpu architecture, or for the millionth time change how app signing works, or add some new security feature that breaks your app. Now you need to make your app work properly on the new platform, switch APIs, all the fun. Or, there's some critical vulnerability in library you used and customers are deleting your app from their computers (a lot of companies use automated scanners that check against published CVEs). It's most fun when you learn that the new version that fixes the vulnerability completely breaks compatibility with the old one and now you have to rewrite all the code that used that library.
Also, maintaining open source projects is not fun. It's a lot of work, in most cases unpaid, thankless, and building a community around a project is really hard.
People think computer as magic. That would be nice to make people understand that it's not. That's pretty much a dumb machine where we put our intelligence to work.
Everyone can code.
Anyone can, but not everyone needs to
And not everyone should.
I didn't want to say that because it sounds mean, but yes, pretty much
Not everyone should
That coding interviews are even by the tiniest measure good indicators of how capable a candidate is for a software engineering job.
I saw a great thread on Mastodon about this: link
Myth: You are lazy.
Truth: It's highly probable you are neurodivergent.
While, accurate numbers are not available, I have seen people estimating that 20% of people working in FAANG are neurodivergent. If coding comes naturally to you but the laundry is your mortal enemy, it's worth learning about ADHD/ASD and other common disorders. Being a coder can be a sign, the immediate feedback helps a bunch of us, or as Russel Barkely says "when you solve a problem on a paper, NOTHING HAPPENS".
Edit: Rephrase.
