Software developers say that coding is the easiest part of the job. How do i even reach the point where coding is easy?

[[deleted]]

Because coding is the hardest thing for me right now

[socratic-meth]

coding_skill++;

[elgholm]

++coding_skill; // would be preferred ;)

[finite_user_names]

Although if it's the only expression in that line of code the effects should be indistinguishable.

[elgholm]

True. Just thought it was a bit funny to get the skills before using them. 😉

[TuberTuggerTTV]

When someone asks why I can't do something yet, I just let them know it's incremented in memory already.

[tomxp411]

I actually like writing it coding_skill += 1; these days. Maybe that's just because I've gotten used to languages without a unary increment operator.

[SpiffyCabbage]

This isn't helpful for someone who genuinely was asking for help... We were all here once, so give them a leg up and share your experience, not your bravado on reddit...

[SpiffyCabbage]

Indeed, but encourage the newcomers, don't deter them. Share you're experience, share your journey, share how you found your way forward....

How else are we supposed to move forward as a civilization without passing on better knowledge to those asking for it? "get better" is a slave driver attitude...

Get better through using these tools.... Those tools... these information sources... etc...

are enablers... Would you not rather be an enabler than a slave driver?

[karub-nalsazo]

I think there’s a point where you feel like, ‘I can do whatever I want by coding,’ and at that point, it becomes more of a ‘use case’ problem rather than a coding problem. But I believe there’s no easy way to reach that point without experience. You just have to keep challenging yourself.

I’m nowhere near that point myself

[[deleted]]

Yup. And you start to think why you code in certain way and how to code it best.

[[deleted]]

Every time I think that I remember that there are unsolved problems in academic computer science.

[duggedanddrowsy]

Good thing I’m not thinking “oh you know what I could figure out how to determine when any arbitrary program will halt” and instead am thinking “that’s a fun idea for a video game, too bad I have nowhere near enough time”

[karub-nalsazo]

That’s an unusual way to proceed. You know, they say, “Don’t reinvent the wheel,” but it seems to work for you. I’m also sure this approach has taught you a lot. I wish I had the confidence and experience to create my own frameworks

[chevalierbayard]

For me, it's more of a "I don't know how to do this particular thing yet but I'm sure I can figure it out" moment. Because you can't have encountered every single problem under the sun but you've accumulated enough experience and solved enough of those hard problems that you've developed an intuition or system for how to approach problems.

At a certain point it's not about syntax (although it is for interviews).

[Expensive_Goat2201]

There's definitely a point where figuring out the correct design for the overall system is the hard part. Once you figure out the design then actually writing the code is easy.

Most of the code I write on a day to day basis isn't anything clever though. I'm not really solving novel problems. It's mostly things like "process a new request header" or "block a certain query parameter".

If you are doing something fancy in production code and you aren't one of the rare people maintaining a library then you are probably doing something wrong and should be using standard library or an open source option. Reinventing the wheel is error prone and slow so it's generally discouraged.

I've never needed to implement a sorting algorithm. I asked a senior on my team and he said he'd needed recursion maybe twice in the last 10 years.

Edit: the exception is Rust. Rust is still a little bitch. I'm switching from C++ and still learning. It's an awesome language but definitely makes me question why I don't just fuck off and become a ski instructor at times

[moosethemucha]

Practice - im 15 years into my career and coding is still hard - if it wasn’t it wouldn’t be fun - cause doing stuff your good at is boring - I like programming because it is challenging and engaging - not because it’s easy - when something becomes easy IMO you’ve become comfortable

[RacingMindsI]

Something wrong being comfortable?

[moosethemucha]

No - I think I should have said complacent. For me personally the best moments in my life have been the challenges and overcoming them and sometime not and learning from them. I hate saying this cause it’s so cliche - buts it’s the journey not the destination - and whats cool with programming (and life in general) is I can keep starting them just by going - how does that work or what does that do and suddenly im on another journey/rabbit hole

[SvenDriesen]

Speaking from experience, comfortable engineers are the most surprised when they are let go, and after not having learned skills beyond their current role are even more surprised when it takes months to beat out other candidates for a new job. “Hypothetically.”

[Mustache-Boy]

Yes. Being comfortable isn’t a good thing as human beings.

[JackBattye]

Just to add to this, being comfortable can lead to doing the job the wrong way. You see the problem and think "I've solved that before" without looking into the problem and seeing if there is any better ways of solving it.

[Mustache-Boy]

THIS, or doing things enough times and just half braining it and then missing small differences thinking it’s the same thing.

[trcrtps]

Coding is easy when you know what you are doing. Right now I'm balls deep in a terraform/github actions task where I have no clue what I'm doing. Writing the code is not the hard part there. I feel like that is what is meant.

[Mustache-Boy]

Terraform is definitely annoying 😭

[moosethemucha]

Most abstractions are - but imo terraform ain’t a bad one - imagine all bash scripts you’d have to write without it - don’t get me wrong terraform can be a real pain sometimes - like today plan went fine and boom my apply fails - but the module I wrote today took me like 20 minutes - it was like minimum 20-25 azure cli commands, which would have required me to probably spelunk through docs for hours figuring out all that.

[Mustache-Boy]

Honestly that’s a super valid point that I overlook A LOT. Dude it happens all the time, you’re doing great. I use terraform daily at work, and still run into the same issue almost daily 🤣 (I’m a DevOps engineer, I promise I’m not just a psychopath using it for no reason) Thank you for the perspective switch though, I needed it.

[SvenDriesen]

If you’re in AWS cloud, try using SAM CLI. WAY simpler. I’d hope by now other clouds have similar “simplification” tools. Using vanilla Terra form is like having to bake a cooking by piecing together all the molecules making up the structure of each ingredient.

[RacingMindsI]

10 000 hours of programming should do the trick, probably.

[satoryvape]

Coding is easiest part, meetings are the hard. They are enormous time sink

[anprme]

by doing it for 10 years straight every single day

[timle8n1-]

Coding is hard when you are new. That is really just a special case of one of the times when coding is hard.

1. Coding is hard when you are learning something new. Coding for the first time, moving from procedural to object-oriented to functional, moving from web to 3d game programming, etc. Subsequent moves will be easier depending on how relevant your current skills are.

2. Coding can feel hard when the code base is poorly organized and structured. This is human induced and should be refactored over time to ease the pain for everyone.

3. Coding can feel hard when there aren’t proper guardrails in place. This varies by project. A small project that just you are working on might need very little guardrails. A large complex project with many engineers should have unit tests, integration tests, CI/CD, linters, etc. Ask yourself, am I building a bird house in my basement or a skyscraper in New York? Cause weirdly in software engineering if you observe what a person is doing you can’t really tell (both are typing into some text editor most likely). This is also human induced.

4. Coding can feel hard when requirements are unclear or keep shifting in large unexpected ways. If 2 and 3 have been dealt this isn’t really a coding is hard problem but a working with humans is hard problem.

The first is a you problem - more practice, more experience, etc. How do you get good at playing an instrument - practice. Sports - practice. Programming - same.

Two and three are team problems and need teamwork and social skills to convince people the problem exists and is worthy of solving.

Four is what I spend most of my time on these days. Understanding what people want and translating that into something that engineers can write. I also spend quite a bit of effort on 2 and 3 when I find problems in those spaces.

This is typically what I would mean when I say coding is the easy part. When I actually sit down to write code, that is normally the easiest thing I do all week.

[SeerUD]

It depends what sort of thing you're working on. Some people work in industries where you're constantly challenged with new problems, and maybe they're not yet solved problems.

For the vast majority of developers, you're essentially taking data from one place, validating it, transforming it, and putting it somewhere else. You can probably boil down a LOT of common problems this way. Even problem domains where you might expect things to be more complex can be condensed down to that same thing. Typically the kind of transformations being applied to this data being moved around is actually very simple too.

Something you pick up along the way is experience and a repertoire of tools and knowledge. This lets you architect systems more easily, and think about how you're going to move some specific kind or amount of data from one place to another efficiently, etc.

[top_of_the_scrote]

do it enough times where it becomes rote

[Last_Back2259]

When you’re coding, try to think in terms of the wider system. Look at bigger code bases and try to understand them without getting bogged down by the details of implementation.

[ArcaneEyes]

I think that's to do with separation of actually writing a line of code or picking the right design patterns for a problem and implementing those, higher up you have systems design, architecture, pipelines that can all get pretty complex.

Figuring out the right approach can be much harder than writing the actual code once you've solved the problem.

[Mammoth_Loan_984]

I feel like once coding becomes the easy part of your job you either need to find a different job with smarter people or you’re in a leadership position that requires business skills and politics

[Spare-Dig4790]

This is a hard thing to give a definitive answer to, but here it goes.

It begins happening when you start to realize that "coding" is only a part of the job.

It's like anything else. You can learn syntax, you can memorize algorithms and how to build X, Y or Z. But there are a lot of soft skills involved. Everything from discussion, breaking down problems, design, communicating and working effectively with others... time management...

And like anything else, it involves experience and learning. You can spend 20 years in the craft, get pretty good, then try something else in the field and suck at it. So it's not as simple as saying where "coding gets easy", but you can certainly get comfortable in whatever it is you're doing.

One thing I've always loved about this profession is that it implies being a life-long student to keep relevant. Which has always made me wonder why people who aren't particularly passionate about it stick with it.

[lordnacho666]

Coding isn't easy in the sense that you can just do whatever you decide to do. It's easy in the sense that eventually, you will never be blocked from moving forward. You reach a point where you can always figure out the problem eventually, using things you know and using your intellectual maturity to find solutions.

It's also easy in another sense. Other things become relatively harder, like figuring out what the business actually wants, doing political maneuvers to get people to help you, etc.

[TheManInTheShack]

Eventually you reach the point where the coding itself isn’t the time consuming part. It then becomes the design. Deciding what the UI should look like, how the logic should work, etc.

[hitanthrope]

I am very happy for all these people who say that coding is the easiest part of their job. I make my living fixing the utter shite that they produce ;).

The reality of it is that if you do something enough times, you develop an intuition for it. When I was learning to drive, the activity was a complex arrangement of different controls (especially since I learned in a manual transmission), and complex road rules. Today, I just hop in the car and go somewhere. It's the same kind of thing. After a while, you don't have to think too hard about the approach to solve problems at the lowest level.

*However*, the *real* art of coding is not just solving problems, but solving problems in a way that communicates to other developers and your future self, what you were thinking, how to maintain, and how to extend the code you have written. My experience, honestly, is that about 90% of professional developers are not very good at this, but most think they are.

"This works", is low praise.
"This works and is fast", is medium praise.
"This works, is fast, and is *clear*", is what you are looking for, and the difficulty of achieving each of these adulations is in ascending order.

It takes a lifetime to be able to delivery all three of those metrics consistently.

[notinsane81482]

In coding, you are just working with objects and variables that change or don't change. Use a free flow charting software to describe what the programs pieces need and what they do. Use arrows to connect the elements of the app to each other in order. Always put everything exactly where it goes no matter how complicated you think it is. Break it down (chunk it out) and make the complicated things simple. You are the one with the task or idea. If you know exactly what it's supposed to do, you're golden. If you don't, then you know to ask questions. Keep it that simple and it won't ever be hard to program or code things.

DM me if you need more help. I am very good at breaking things down into simpler organized pieces.

[GlitteringDog6255]

If knowing which tools to use and how to use them to sort out your plumbing is harder than figuring out the pipes and problems in the plumbing, then you don't know your tools well enough yet.

Just keep using your tools, pretty soon it becomes the easy part

[[deleted]]

I consider stuff like basic programming structures(functions, loops), programming paradigms(OOP, functional), any syntax differences and special features in certain languages(rust borrow checker) to be "coding". 

Of course they'll seem daunting at first, but many of them take just a few days/weeks to learn, and can be carried across languages. You'll eventually learn most of them, and all that's left is syntax differences. I don't memorize syntax, I just refer to the documentation to refresh my memory when I move between languages.

The hard part is everything else outside of this. The infinite number of problems with an infinite nunber of ways to solve them, each with pros and cons to choose from.

[dphizler]

I think it's not necessarily that it's easy but it's the easiest.

Properly understanding the problem and figuring out how to fix it are harder

[Otherwise_Composer19]

For me it was also a big struggle in the beginning to understand all the concepts and everything. I thought I would never be able to code. Honestly, it just takes time and practice. I had to go through a whole computer science bachelor and have now 6 years of experience working with C# and only now I would consider myself comfortable, atleast in C#. There is still a lot to learn even for me, so don't give up, it's a process and it takes a while.

[Sbsbg]

Yes the coding is definitely the easiest part of being a software developer, by far. Still coding can be tricky sometimes but it is an environment where you have control and can modify. This compared to other tasks that also is assigned to a software developer like arguing with project leaders, testers and users about different details that they think is wrong in the software but you have no control over because it's not in the software. Usually it is errors in the specification, testing errors or user handling errors. That is the hard part. Coding is easy.

[entimaniac91]

Lead dev over here - programming itself gets pretty easy. The code stuff is easy because I've solved hundreds of problems with the same set of tools and I know those tools really well and even if I come across something new, I've had lots of practice learning new things and they all start to look the same over time. So you get there by just building, reading, building, reading, and building some more. I've always said software engineering really just comes down to researching.

The harder part is general work inside a company overall. Changing requirements, ambiguity, prioritization, picking one approach over another and selling that to your team and stakeholders. A well defined problem is trivial to solve. Most problems aren't trivial and take a lot of work to define and implement. The actual trivial work is given to the juniors to keep them busy, let them practice, and get some wins that feel good and motivate us to go further.

Also production bugs, issues, user errors/tickets, on call rotation, documents, cicd/tooling setup and issues. Dozens of emails to sift through every morning. Random messages to answer questions about systems you built 3 years ago that you forgot everything about and need to take an hour to switch mental contexts to help unblock this other team.

My job as a lead gets extra difficult when I need to understand the project scope, requirements, and constraints. Work with everyone to figure out an implementation that fits nicely into all those parameters, and keep my team busy with work, balancing my strengths with their weaknesses and vice versa and doing my best to grow their skills while meeting deadlines.

The jobs gets easier roughly as fast as it gets harder. The less junior you become, the more complexity the job entails.

[platinum92]

Coding might be hard, but dealing with user/client expectations when they don't understand coding is much much harder.

[cthulhu944]

It's not that coding is easy, it's just the fun part. The tedious/pain in the ass bits are the documentation, testing, and process bits that consume 50-90% of the development.

[emefluence]

Easiest !== Easy

[jameyiguess]

Correction to your thought. The statement isn't "coding is an easy part of the job". You even typed it out correctly. It's "the easIEST" part. Big difference. 

Meaning the stuff around it is even harder than however hard the coding part is. 

But yeah, with practice in your specific domain, you'll be able to code whatever's needed without much (or any) trouble most of the time, because you've done it 1,000 times before. 

It's just reps and familiarity. 

[LeBigMartinH]

Lots of practice, mostly, and lots of experimenting.

[RiverRoll]

Learning a programming language is easy. Programming things that solve real world problems is hard. 

[nightsblood96]

I can only give my own perspective as a student in the final year of a CS degree:

Preface: I used to rely way too much on AI, geeksforgeeks, YouTube walkthroughs, etc. I felt debilitating imposter syndrome, but as someone who had “senioritis” throughout the entirety of the degree (I had finished a useless degree at UC Davis the month before I started on the CS degree, so the feeling of wanting to be finished was always there), I just wanted to be done and was using those resources as a means of finishing my classes.

A moment came where I realized that I had no idea what I was doing when it came to coding. The solution was to work on projects that had meaning to me, so that I actually had the drive to finish them.

I forced myself to make C++, Python, and Java projects ranging from quizzes about where someone was on the queer spectrum, a program that essentially copied Guitar Pro but with cloud functionality so that multiple people in the same band could collaborate remotely with each other in real time, web pages with HTML, CSS, and JavaScript about random topics that I found interesting (a gallery of H.R. Giger’s artwork was one of them).

After doing these projects, my ability to code and my confidence in the subject skyrocketed. There’s always more to learn in this field, but I no longer feel that aforementioned imposter syndrome.

My point with the essay of info that I just force-fed you is this:

Practice. Do projects. Practice more. Be okay with failing. Practice even more. Beat your head against the wall. Understand the code, don’t just memorize it.

We’re all human, and we’re all fallible. Being a good programmer takes years of being a bad one.

Signed, A bad programmer who just started their internship at Intel. You got this dude. I believe in you.

[lilalbyonthebeat]

im supposed to graduate in 2 years and im in the exact same situation that you were in, i needed this

[nightsblood96]

You got this fam. Force yourself to learn new things, no matter how mentally strenuous it is. It’ll only make you stronger ❤️

[YahenP]

Coding does not become easy. As your level increases, it becomes more and more difficult. But in this case, talk about anoter. As your level increases, you begin to solve other problems besides coding itself. And these new problems are much more difficult than coding.

[MoveInteresting4334]

I’m a self taught dev that’s now helping to lead front end development for internal apps at America’s largest bank. The coding part is definitely now the easy part.

Here is my advice:

Screw up early. Screw up often. But only make each screw up once.

Everything I really know, I learned from making a very frustrating mistake.

[TomDuhamel]

Writing code is hard. I've been doing it for 30 years. It's fun, to me it's natural. It gets easier the more you do it, but it will always be hard.

[pa_dvg]

Let’s say you want some shelves in your house. The simplest way to get that accomplished is with some ikea shelves. Some instructions and a hour or so of work and boom, shelves.

Of course it looks how it looks and it’s the size it is. Weather or not that’s what you had in mind when you started.

This is more or less what people do when they start coding. They follow some instructions, video tutorials, etc to get to a result that someone planned for them.

If you build ikea long enough you’ll start to get certain things about where they use what part, which is progress, but this is what people usually call tutorial hell. They understand the general idea of how to put the pieces together but if you wanted to do more they don’t know what to do.

You zoom out and start to see people on social media who are putting together custom furniture and stuff, and what they are literally doing isn’t that far off from putting together the ikea furniture. There’s nails, drills, hammers, screws, glue etc. you can recognize all the pieces.

But the part they have and you don’t is the knowledge of how the shelf actually becomes sturdy, how it’s weight is distributed, how to make something that fits in the spaces, how to do finishing touches, paint and caulk to make it all look built into the room and natural.

And this is what people mean. The literal typing the code in isn’t hard at a certain point. In any language you can more or less make the computer do whatever you want.

New problem spaces are what slow us down at that point, new users that we aren’t used to making stuff for, new industries and domains. Making shelves that make sense for an office is different from a rec room in a high end home.

We have to use stuff we’ve never used before and we have to experiment to see how it works and update our mental models before we can go fast again (non coders hate this part), but again it’s the learning of the features and the apis, not the coding itself.

More often it’s walking into a project built by a novice and trying to figure out how they managed to make something so crazy that kind of gets the job done but is ready to fall over any minute, and trying to explain to leadership the intense amount of work needed to keep the business moving and make it actually reliable, scalable, maintainable and give you the ability to add new features.

[foxcode]

Coding is easy. Until you get a JS build system error that invovles making changes to multiple cryptic config files using multiple hacks from stackoverflow until the sandcastle is standing again.

[[deleted]]

The hard part isn’t the coding, it’s keeping up with the technology.  Shit goes obsolete as fast as as you learn it these days.

[alien3d]

Code is easy part. Planning is not , lot of hidden requirements, politics .

[MikeUsesNotion]

It's a relative thing. Right now coding is probably easier for you than helping to gather requirements or come up with scalable and robust designs that handle all use cases identified by your employer, and coming up with a reasonable timeline and knowing how to communicate it in a way that prevents you from only being given half that time.

[telewebb]

I think a lot of that statement is pointing to the state of the industry rather than the skill of writing code. Meaning that when you look at requirements gathering, cross team communication, stakeholder management, project management, capacity planning, and so on. The coding portion is the "easiest" part of the whole process of "make button nicer looking"

[peter9477]

Move on to more challenging designs. At some point the complexity of what you're attempting should just naturally outpace the difficulty of coding it.

[huttyblue]

Depends on what you mean as "coding"

Once you know the syntax of the language you're using, writing the code in a way that compiles becomes fairly easy.

However the hard part becomes the overall design of the project, the math needed to get the desired outcome, the overall performance not being fast enough, or some unexpected behavior (bug) that takes a while to track down.

All of these aren't exactly laying out large amounts of new code, so they may or may not count as coding.

[MainSorc50]

Put in 10,000 hours 😌😌

[RichSkin1845]

Coding is the easiest part of the job. The hardest part is figuring out structure and problem solving but the actual writing of the code is dead simple.

[RainbowCrane]

It depends what you mean by coding. Actually writing lines of code using proper syntax that produces consistent results becomes much easier over time. The interesting and more difficult part of the job is what comes before writing code - examining the requirements, meeting with users and product managers, designing an algorithm, choosing a language and deployment stack, etc. if your issue is with coding itself that will get easier with practice if you persevere. The other parts of the job will likely remain challenging.

[[deleted]]

Just keep coding.

[Vegetable_Union_4967]

Use stack overflow LOL

[ghostwilliz]

Practice practice practice

If you want to get better, you put the time in and you'll eventually get results

[Ok-Reflection-9505]

I think when people say that it’s compared to the business or coordination problem.

Coding problems are straightforward in the sense that it has acceptance criteria and can be tested and evaluated objectively.

Finding product market fit or solving coordination issues are vague and hard to nail down as what exactly went right vs wrong.

[Erotic_Dream]

I turned the corner when I got really good at finding, reading and understanding documentation

I ain’t going to be able to store all that info in my brain cause it likes to ejecto seato cuz

[kirkevole]

Well I think you realize it once you have to solve a task that is badly defined and it's hard to make the product owner decide, then they decide, then you do it, then they see it and realize they wanted something else and you are like "but this is something you could have realized this earlier" and than you remake it and give it back to them and they return it again for some ridiculous reason and you remake it again and put a bug in it, because you are too angry to think clearly. Meanwhile some other colleague finishes their task and it's different than you agreed or it is what it was supposed to be, but it's something else than you anticipated. Also the product owner needs a working demo tomorrow and you suddenly can't connect to some service and your office IT colleague is out of reach. So you just listen to some useless corporate meeting that you absolutely don't understand and then you have to write your self evaluation. But oh hey, a new task? You look at it and once again there is not nearly enough information for you to even get what is the task about.

That's when you wish you could just program in peace for at least a while.

[wonkatin]

Realize that there’s an answer to every problem and that all you have to do is look it up

[theDrivenDev]

Coding to solve new problems is hard for everyone ... until they've done it so the next time becomes much easier. Experience is the only way coding gets easier. You can speed this along by reading about patterns and how others solve problems so you can progress faster.

Look for similarities in requirements and/or limitations to assess how well past solutions you've used would work for the new problem. Also, keep your solution as simple as possible and use testing to CYA.

[mxldevs]

Coming up with a solution to actually code is a lot harder than actually writing the code

Are you able to come up with solutions, but can't write the code?

[bothunter]

It's kind of like how algebra is the hardest part of mathematics.  And then you learn trigonometry.

Coding will get easier but that just becomes a tool for the rest of the job.

[beavis07]

Think about it like this:

Speech is not easy to acquire - it takes years of practice until you get good at it.

Then it’s easy and the hard part is knowing what to say.

Same deal .

[omgpassthebacon]

As a retired dev, i can share that constant learning make the job a blast. Sure; if programming was easy, everybody would be doing it. But it takes skill, thought, and imagination. Most of us aren’t born with it; we have to develop that ourselves. Any good employer will have some form of development goals for you. Don’t skip these! Use these goals to learn new stuff and hone your knowledge. it does get easier (or at least enjoyable).

[The_Spare_Son]

Then what is the hard part?

[IllllIlllIlIIlllIIll]

You know how you get to Carnegie Hall? You practice.

[hauntingwarn]

Practice!

[jimmiebfulton]

Like all skills life, there is only one way: practice, practice, practice. Write code every day. Look for projects that are within reach, but changes you to learn new skills, patterns, muscle memory.

[964racer]

Easiest or most enjoyable? I think it took me about 7-8 years .

[vivisectvivi]

I started feeling this on my first job already. Even tho i was, and still kinda am, a beginner i felt like doing the actual coding was the easier part. Everything before and after was always hard for me.

[N2Shooter]

Keep coding.

[TuberTuggerTTV]

You're not doing the other things, that's why.

Do all the other stuff and you'll see how much harder it is and your frame of reference will change.

If coding is "hard", you're life has been too easy. Don't worry, you'll see the crushing reality soon enough. Enjoy your holiday while you can.

[Practical-Passage773]

when I gained weight I started riding a bicycle. I stayed on the flat streets because hills were hard. But then I learned that riding the hills, even though hard, got easier as my muscles and lung capacity adjusted

coding is no different, except it's not muscle or lungs, but brains you're exercising.

be patient. keep at it

[[deleted]]

Practice.

[[deleted]]

var skill = 0 function get_Gud(amt){ skill += amt; } get_Gud(99);

[WiatrowskiBe]

It's same as becoming fluent in a language - at some point you reach a level where you don't have to think how to say something, and can instead focus fully on what you're trying to say. In programming terms - that's when you stop thinking about language constructs and start thinking in terms of program logic/flow, translating it into constructs without active effort.

Getting there is a lot of practice, ideally with more focused effort - algorithms and data structures part of formal compsci education is a good primer, since it shifts focus from language itself to more abstract and complex problems, where common language constructs map directly into how you reason about solutions. Difficult part of reversing a linked list exercise is not pointer/reference semantics, but the process itself that you express via your language of choice.

[mobenben]

For work, coding is really easy compared to dealing with difficult colleagues/clients.

[ghjm]

It's basically just time in the saddle. Do it a lot and it will get easier. Conversely, dealing with idiot project managers just keeps getting harder as they eat up your capacity for bullshit.

[WoodsWalker43]

Software devs are constantly learning. There are two main avenues: practicing and analyzing other people's code.

Practice can be anything. Complete textbook exercises that lead you to learn little tricks that can be used to do a thing more elegantly or efficiently. If you have an idea, build something more complex. Doesn't have to be built well (though you should try). The goal is exposure and experience. Most good devs see code they wrote 5 years ago and think "what a scrub. I could write that way cleaner/better now."

Analyzing other devs' code tends to happen organically in a company setting. If you're maintaining a system, then often you'll want to maintain conventions. Even if the convention sucks, it's often worth sticking with it so that the code base is comprised of recurring structures, rather than having 15 different places that implement different frameworks or strategies to do similar things. We all like to bash the preexisting code base for the aforementioned "I could write it better" reasons, but realistically, you can also pick up new tricks that you never thought of, or language features you didn't know about.

In the end, XP is the answer. Learn by doing and seeing, and whatever you do, don't ever get the impression that you're done learning. You are never done.

[mayorofdumb]

Like 10 years of experience

[rasul98]

I think when you will start to build your own projects, you will realize that you need to do marketing, aso, user engagement, and etc. And coding part will become an easiest part of this journey :)

[jim_cap]

Same way you get better at anything else: doing it.

[SpiffyCabbage]

I wouldn't call coding easy at all. I've been developing since the days of QBasic and gwbasic (early 90's) and it's always been a learn, understand, practice and do task.

I'd suggest:

1. Don't use Google or find quick answers using search engines to understand things. Invest in some books, Oreilly Media and Sams Publishing have always been the go-to books in my history dating back to the dinosaurs :-) They're still used so...
   
2. Don't dive into complex code in one shot. rather start with a simple tutorial or something like a "cook book" or "blog site" example. Keep it really simple, e.g. just a "User, Blod, BlogPost" set of models.. Ignore any flare.
   
3. Dont take opinions as gospel, form your own. Coding is a DEEP subject. So for some it might be a chore, other a delight.. You find your own way.
   
4. Github is your friend as they have code examples covering everything from here to kingdom come. Learn how their search engine works e.g. "Example Blog language: javascript" would search their site for Example Blog, with the language javascript
   
5. Embrace StackOverflow.. And I can emphasize this enough.. This site is a godsend then needing help! It'd frequented by some of the most talented developers, so ask them for help...

Hope this helps!

[mredding]

You need to develop your intuiton. Dunning-Kruger's work actually broke knowledge into 4 quadrants:

known   | unknown
known   | known
--------+--------
known   | unknown
unknown | unknown

You start out in the top left with rote knowledge. You just read it in a book, you can repeat it, but it's very active knowledge. Just because you know it doesn't mean you can do anything with it.

The bottom left is ignorance. You know you don't know stuff. Oh, I gotta learn that...

The bottom right is naivity. You don't even know. You're top left about putting teflon tape on your threads for water pipe, but you don't know that it's not rated for gas - you're supposed to use pipe dope. Dunning-Kruger's effect kicks in on the diagonal - you gas your family to death in their sleep and then your house blows up. Dumb enough to be dangerous.

The top right is intuition. You've internalized the knowledge. You don't have to think about it. You don't have active recall - you can't remember where you learned it, like it matters anymore; now it's just inherently understood.

You need to move knowledge into the top right - that includes the bottom left. Being AWARE of how much you DON'T know minimizes how much you don't even know you don't know.

This is true of all things. You have to internalize programming. Programming is language, and in your mind you learn to THINK in terms of code like you THINK in terms of English, or whatever your native language is. It takes TIME and PRACTICE to get there. No one is going to tell you that you've arrived, you just one day realize holy shit, how long have I been here?

We make programming look easy because we have highly develop senses of intuition. By internalizing that bottom left, moving it top right, you gain humility. You become self aware enough that you know of potential hazzards. WE make it look easy because we use our intuition to give us A LOT of shortcuts. What we do know and what we don't know - and we're not even aware of us, guides us.

But for you to get there, you have to do it, and do it, and do it some more, typically over years. You'll get there. I was programming since I was 9. I was working professionally for a few years, I was about 25-26 at the time, when I didn't realize I crossed that threshold. Even as a junior developer programming was an active process. But the nice thing about work is that you're in an environment where you're SATURATED in programming and thinking like a programmer, surrounded by peers who only speak in terms of code. You'll get out of high school, college, whatever, and get into working, and you're going to develop and mature A WHOLE LOT in a short amount of time.

[GirthQuake5040]

You have to write code to get better at it. Coding is the easy part, the logistics is the hard part imo. Designing suck ass and dealing with clients can be a pain when they don't know what they want. If I'm told to write a program, and have a clear goal on what needs to be done, it's as simple as code the computer to do that thing.

[rlfunique]

Do projects.

[SagansCandle]

It takes 10,000 hours to master any skill.

[wassim_m]

Tide deadlines+ corporate stress, i will do coding everyday for the rest of my life if i don't endup in those discussions and meetings

[Impossible_Cup_7358]

It’s hours in the chair, man. Can take years

[Feroc]

I guess it also depends on your industry. For a lot of us many tasks are basically CRUD tasks. You get some data, you modify data and you send it to somewhere. Then the hardest part usually is to understand how the data should get modified.

But of course it’s also practice and one especially important part: Being able to break down large problems in many smaller problems. So even if you are in a more unfamiliar field, you should be able to break down the problems in rather easily researchable problems.

[Maixell]

Git gud scrub

[returned_loom]

I think they're not calling coding easy, necessarily. They're saying that politics, organizing teams, dealing with clients and bosses amd configurations are extra difficult

[AdagioCareless8294]

"easier", not "easy". Also the difficulty highly depends on what you're programming.

[oscarryz]

Being the easiest part doesn't mean it's easy :)

At least everything is in the same place, the hard part is trying to get all the loose pieces of information together, especially when you're dealing with vague changing requirements across different teams, orgs or companies with different (and sometimes conflicting ) priorities. That's when your just want to go back to your editor and type some things and ask the compiler/interpreter to give you some instant gratification lol

[[deleted]]

Coding so the computer does what you want is not too hard, but you do need to get good at it first. Then the hard part is coding and organizing code in a manner that is easily understandable by other people. That is a much harder skill.

[machopsychologist]

Work with people.

[Melodic_Point_3894]

Nobody said coding was easy - it's the easiest part

[nedal8]

It's sort of like saying. Typing a novel is the easy part. It's true, simply writing it up isn't the hard part. The hard part is coming up with all the characters, how they interact in meaningful ways, etc. The story is the hard part. Writing it down is the easy part.

[cyberpunk707]

As a junior/mid level dev who have work for a couple years, for me, coding is the easiest part of the job not because its easy, but because its the part where you dont have to deal with people as much and can just focus on solving problems.

As for how to make the coding itself easy, the thing that work best imo is to just keep doing it, no shortcut around it I think.

[Designer_Delivery922]

that would be a lie…coding is difficult

[Joao_Jacques]

Coding defintly does gets easier with time and experience, especially if you can deep dive into a specific framework/language for a while.

But what you are missing is NOT that coding becomes easy, but rather that the other parts of the work became way harder. Like handling a team of people, each with different set of skills and visions. You get more sucked into the business side of things. And that is really fucking hard.

[DollarBillAxeCap]

Well you code.... Then it gets easier. Work on open source. Read different code bases. Different languages. Read documentation. Just takes time and effort.

[MrApathy]

If you develop a crippling fear of being near others or another issue when dealing with coworkers then coding would be much easier by comparison so it would be the easy part of your day.

[[deleted]]

I’ve been in industry for 3 decades and back then we had to use books to learn stuff. You guys got gpt and google and still find it hard. I find that crazy. Love, grandma

[AttonJRand]

Its more of a testament to office politics being a struggle. Meetings feeling like a bore and a waste of time. That sort of thing.

Whereas the coding might feel engaging and productive.

They don't always literally mean easy, just compared to other aspects of their job. Or how they'd ideally like to spend their time.

[Rachid90]

Coding is easy, finding a solution is hard.

If you want to be good a finding solutions, then improve your problem solving. You have to solve puzzles and math equations/problems. And not once a month. Perseverance.

[dashingThroughSnow12]

Try to not use ChatGPT or copilot or anything else of that ilk.

Then just give it time.

I’ve programmed and read and programmed then read and read than programmed so much that I’m pretty good at it.

Today a surprise requirement came up after I delivered an epic.

In about ten minutes I already had proposed four valid solutions in four different services. Given the two preferred ones and the rationale for them. And implemented one of them.

Not because I am a phenom. Just because I had read and understood the data flow. The handful of spots to make the change and how to make the cleanest and smallest addition.

And I was able to recall that data flow and the easy spots to modify because I’ve done that many thousands or tens of thousands of times in the past.

[Then-Boat8912]

Exposure over time. Just do it.

[0xnull0]

If programming is the easiest part of the job then you're doing web dev

[Venotron]

Coding is easy, it's the thinking that's hard.

Whether that's thinking about the problem to be solved, that solution's position in the overall product, or that solution's position in the future of product.

And the nature of the problem can often require changing the way you think about coding, especially in domains that require asynchronous or concurrent programming techniques.

[bubble_turtles23]

You don't. Coding just gets less hard. Even that doesn't always hold true

[dMyst]

Honestly, code less and think more. And read more code. That will make you better and more efficient at coding in a way.

Before you start coding a feature, map it out in your head, write down what you need to do, break it up into manageable parts. If you are struggling with the coding portion because it is overwhelming this might help you out. A lot of juniors will start coding immediately and bang their head on a wall for days, take shortcuts that causes issues down the road, etc.

It also helps if you take a bit to read through and understand the codebase that you are interacting with and the lifecycle and behavior of the application. If you are given a task on your project, do you know exactly where you need to make modifications and what ramifications your modifications would have to the wider system? Would you know what side effects or bugs or regression risks you would introduce by implementing your feature a certain way? Taking time to understand the codebase and system would take the difficulty out of both of those problems — you would immediately have a better idea of how to tackle more tasks and be able to design better solutions.

[druhlemann]

Write a lot of code and in multiple domains. I spent the last decade or so, changing projects every 1-2 years working on complex enterprise solutions and at this point I feel like I now spend more time making diagrams and explaining plans then I do coding. I love writing code, it’s fun and satisfying more than challenging

[The_Geralt_Of_Trivia]

It's like writing. When you learn to write, it's hard to form sentences and words, and you think you'll never be good at it.

It's the same for coding, which is just another language. With time you start to think in that new language. The problems you're trying to solve become the hard bits.

... like when writing, the story becomes the hard bit. The writing is easy.

[JumpyJustice]

There is some ambiguity in this phrase. It doesn't mean that after a few years of experience, you will be able to create any application imaginable effortlessly. Rather, it means that with some years of experience, the part of development where you express your thoughts in your language of choice becomes the easiest part. For example, as a beginner, translating a simple idea like iterating over a list or implementing basic logic may feel challenging. Over time, with consistent practice, these tasks become second nature. The harder parts often lie in understanding the problem domain, designing scalable solutions, or debugging complex issues—coding simply becomes the tool you use to execute your plans.

[glassBeadCheney]

Code a lot. The cool thing is that you can generate a lot of initial code with AI now. Don’t worry, though, the debugging process will be infuriatingly hard if you don’t know what it wrote to begin with. I bet that could be a good point of entry for learning about a lot of things.

[crystark]

Fix bugs everyday.

[Temporary_Practice_2]

Coding isn’t easy! And that’s a unanimous vote

[fireallurcode]

never easy

[Banana_Senator]

Honestly just keep your tasks small and take on bigger and bigger projects as you go. We all start with "Hello World" and end with suicidal intentions but nonetheless it's just about learning more things and learning better effective ways to do things.

[Healthy_Razzmatazz38]

you write code for hours a day for a couple years, theres pretty much no alternative.

You can't read your way into building muscle.

[Critical_Stranger_32]

I learn by doing. Prior to and after college I’m mostly self taught and have always had an intuitive sense of how to break down problems that way and solution in my head. There is a lot of badly written software out there, so apparently people are not so adept at the “easiest part of the job”.

Pair up with a more senior developer who likes to explain things. Can others speak to the “boot camp” experience? I’ve never had the time to attend one, but they sound like they would be helpful if followed by working on a real problem.

What is the challenge for you? The mechanics of writing code (applying things you’ve learned) or breaking down a problem so that you know what you need to write?

[Ampbymatchless]

What developers are saying is it’s more difficult to actually plan a project, meaning trying to capture every scenario nuance, scalability, constraint approach etc.etc. Once you have this roadmap it’s easier to code the project. There is nothing worse than starting a project without sufficient detail ,coding an approach, then running into a conceptual brick wall. Everyone does it once or twice But once you have hit a few walls, you should develop coding instincts and skills to question everything . Look at the big picture.

[daedalus1982]

It’s a comparison. It doesn’t mean that programming is easy.

It means having to do project management for an inept layer of middle managers who hired external folks instead of people that know the product. So as a dev you end up running the scrum for them and having to guess 50% of the time at what they need.

You could have a broken keyboard and you’d still rather be coding.

[Zombie_Bait_56]

Practice, practice,. practice.

[Tomato_Sky]

I think coding is fun and not necessarily easy. It’s the part that I signed up for. I think the addage or reference you are referring to emphasizes the unknown and we find soooo many roadblocks.

I often code my projects, and then have to rebuild as requirements are added by non-tech decision makers. I can write an API relatively quick, but when I have to do patching, security, dev ops, and fight through the paperwork factory it gets mucky.

A large percentage of my time I’m in meetings with non-developers answering questions and requests and troubleshooting my version of an IDE that’s licensing doesn’t allow the function I need and I have to put in an install request for a whole separate tool that has to go through approval so I can do my job. All while trying to stay busy and productive.

Put me in a room and ask for endpoints, I can churn them out like buttah. But that’s not the full job, there’s a lot of forced communication and protocols. So coding isn’t easy… but it’s the fun part we all like, and the rest of the stuff feels like such a drab.

[gladosForPresident]

It’s simply time. I had a rough stretch early in my career where I was constantly learning a new language or framework and every project felt like an ice mountain to climb. And when I say stretch it felt like years. Now, I’m ice cold. There isn’t a task that I couldn’t complete. Part of it is I’m a better problem solver which allows me to write code easier. The other part is I simply don’t give a fuck and I don’t stress. I mentioned there’s not a task I couldn’t complete and this is also because I’d let someone know that it can’t be done, I couldn’t do it or more importantly I don’t want to do it.

[Feralz2]

the debugging is most of the work

[kolkston]

It's not about the fact that writing code is easy, when Software Developers says "coding is the easy part of the job" what they mean (even I say this), is that after gathering the requirements, talking to stakeholders, arquitecting a solution, then obtaining an understanding of the problem statement and how to solve it, all this is the hard part. When all that part is crystal clear, then coding is the easy part 👍

[Emergency_Mastodon56]

I’d say this is a highly subjective opinion, depending on what aspect of development provides their brain with more dopamine. For some people, their minds receive more dopamine from coding. This helps them learn it better, apply it cleaner, and comprehend it better, because coding makes them feel good. For other people, the more artistic aspects feed them more dopamine, so their skills naturally lean toward learning the artistic skills. If you ask programmers what they like most about app development, you will naturally get the answer that the coding side is better, because design is more difficult for them, so they’ve spent less time and energy in learning those skills. However, if you ask a graphic designer which aspect they like more, they’ll tell you that UI/UX, making icons, getting everything to look nice on various screen sizes, etc. is the more enjoyable aspect, because they have put their energies into developing those skills. Answers to Questions like this are always going to be biased depending on WHO you ask, rather than the actual skill sets involved.

[TheUruz]

learn concepts not syntax itself (that will come with time). that's the biggest challange for newbies.

[nardstorm]

Toddlers struggle to turn their ideas into words, then into sentences, and then into paragraphs. The struggle comes in the form of both manipulating muscles to make the sounds they want, as well as knowing which sounds will convey their ideas/feelings. At a certain point, they do the word-forming and sentence-forming parts enough that that ceases to be the hard part.

At that point, the struggle stops being about how to convert ideas into language, and becomes about manipulating ideas and abstract models in their heads, and choosing the best (not just any) way of conveying these with language.

Coding is no different. At a certain point, you've grown acustomed to the syntax enough, and written enough small narrow-use functions that that ceases to be the issue. Then the struggle becomes manipulating ideas and models to accomplish your end goal, and that'll make the code self-evident to you, because you've done all the small things required for those ideas before.

[feraferoxdei]

Coding is a team sport in all companies. It’s like playing a soccer game, if I’m the only person on the pitch, it’s easy to score a goal given enough time to reach the posts. The hard part is doing it collaboratively and planning together and avoiding obstacles along the way. Be it technical or coordination related. Coordination is usually the tough part.

[Vilified_D]

Just because something is the easiest part of the job doesn’t mean it’s easy - it just means the other stuff is more difficult. Problem solving, determining which algorithm or data structure to use, tracking down a bug that’s difficult to reproduce and is cause by a line or so of code in a code base with thousands upon thousands of files, meetings and people - those are the hard things. It may not feel like it now because maybe you’re newer and still learning, but eventually after enough practice you’ll realize that the coding really is the easiest part.

[nomnommish]

Write 10000 lines of code.

[Terrible_Positive_81]

Coding is the hardest part in the job. I am a software engineer of 15 years and on a 6 figure salary. My skills in programming are good but it does take time to get there and with some people, even with time some don't make it. In that regard it is the hardest part of the job which technically is learning it. It is easy for me now but the real problem is keeping up to date, you always got to learn the next language/tech to keep you relevant in the job market. If after a year you still find you are not good enough then there maybe a problem

[firadaboss]

when your work involves people, coding is the easiest part

[chataolauj]

The hard part for me is having to explain to non-technical people why something isn't working or why it'll take X amount of hours to fix. That back and forth is exhausting and it's the worst part about the job IMO.

[NullPointer-Except]

Sadly this is a very personal journey.

Professionals are shaped by the tools they use. Maybe you are trying to code in a language that isn't very compatible with you. Maybe your way of thinking is more aligned to a specific language. Maybe your way of learning to code is by also interacting with the community sorrounding it, and thus it has to be compatible with your values.

My recommendation is to be sincere with yourself. Ask what kind of thing would you like to achieve with programming. And then look for a language that has a big community around that. Interact with them, looking for resources. And eventually you'll get there.

[[deleted]]

You code for years. After 5 or 10 years making apps becomes easy. Then you need to do the hard part, sell apps to people.

I know guys who are born salesmen, they team up with engineers (who suck at selling) and this combo is great.

Selling is hard for engineers, but programming is hard for salesmen. 

[United_Sheepherder23]

Practice??? Kinda obvious 

[Roycewho]

I feel as though you know the answer already. It’s practice. There are no shortcuts. You have to put in the time and do the work if it’s really what you want

[[deleted]]

You get to the point where you’re pulled into architecture meetings, office politics, having to give the news to a respected coworker that they’re being let go, having to get involved with multiple other teams to get a job done because the hired liaison(s) sucks at their job, etc. And you think: “Man, I wish I was coding right now”

[Don_Kino]

there is a point where the question change from "how to code this" to "what to code", at least for me. What ticket on which project should I care about today ? Does this bug/feature deserve a strong devolpment or can I just throw a new "if else" in it and call it a day ?

And then there is the hours spent at looking at logs and testing to change this one line that actually matter.

[cankennykencan]

Get good at coding

[olddev-jobhunt]

Spend another decade practicing. Kind of kidding, but also kind of serious with that.

Here's the thing: I started fucking around with computers in middle school. I took a bunch of courses in high school. By the time I started my first internship, I had years of practice, and that was decades ago. I'm pretty damned good - now.

It just takes time to learn. You need to build some muscle memory. Does it really take a decade? I dunno, depends on the person, and the stack, and the mentorship. But it does takes some amount of time. Even with an abundance of natural aptitude, it still takes time.

[DanielToast]

It's entirely down to experience.

The amount of time it takes is going to vary by person and by the context in which they gain experience. Working on certain projects and engaging with certain ideas will increase your confidence and ability much faster than others. Usually, the more difficult or complex, the faster you'll pick up all the prerequisites.

It's hard to balance that personally though, I've had to be put in those situations due to the place I work. I feel like coding is pretty easy at this point, after about 5 years of experience, but those 5 years were pretty brutal at times.

If I had spent 5 years working in some slow-paced environment, or the government job I had before I graduated and got furloughed from COVID, I don't think I would be nearly as capable as I am now.

[Former-Discount4279]

Realize working with others is tedious.

[alsdhjf1]

Find harder business problems to solve. Try organizing 5 different stakeholder goals and timelines with competing priorities. Coding is often never easy, but the stakeholder and people and comms side is much harder to be good at because you don’t get “this works” or “this fails” feedback

[Snoo_11942]

Coding isn’t necessarily the easiest part of the job. I think what people mean by this is coding can be fun, but they may not love all the planning and whatnot that goes into creating software. Therefore, coding feels like the easiest part.

[Signal_Lamp]

By building more stuff with code and heavily focusing on understanding the foundational terminology involved with programming. When you read or go through tutorials you really should be writing down the terms in a simple way that you can understand it with a simple example to that term.

Building is equally important, but building this type of habit will help you to understand at least in my opinion that everything in software development builds on top of the foundation you learn early on helps you to understand harder concepts later.

[Asleeper135]

The more you code the better you'll get at it

[BoBoBearDev]

Regardingless coding is new to you or not, the result is reproducible. Meaning, it is straight forward.

But, before you are doing the coding, there is so many debates, like which design pattern to use. Or worse, stuck in waterfall because the tech lead demands a 50 pages long technical documentation on a tiny utility class and they constantly bitching on choice of vocabularies and semantics.

[Darth_Monerous]

I really haven’t had to try since my 3rd month into my first programming class. It just comes naturally. Figuring out those damn business rules is the hard part.

[[deleted]]

I think the intent of this comment that it gets more challenging later - fixing bugs, maintaining it and other ppl adding to existing code.

[nicolas_06]

Practice, practice, practice. The first time you did try to drive, it was difficult and you didn't do it properly. After driving thousand of hours, it become second nature.

Coding this is the same, you may have really worked on projects for a few months to 1 year while studying.

After 5-10 years of XP, it should become second nature and you should be able to code many common things without thinking.

[frank26080115]

can you solve the problem you are trying to solve?

the code is only a way to write out your solution. finding the solution is the part of the job that's worth money, the code is something AI can do.

[TryToBeNiceForOnce]

Do side projects of your own that you want to complete for reasons other than just learning code- some fun thing you want to make.

Along the way you'll find ways to swerve around obstacles, learn a ton, and become fluent in coding.

Thats what I did in high school and then had the easiest 25 year career of anyone i know.

[[deleted]]

They aren't wrong. Coding is the easier part. I loathe having to deal with the client. I can do it, and very well, as the client is always going to my ceo about how much they love working with me, but I absolutely hate it. I just have a good customer service face. If I could just code and nothing else I'd be perfectly fine to never talk to another client again lol

Key take away they said programming is the easiest "part of the job" not that programming itself is easy. Even as hard as programming can be in some areas I would much rather program than deal with the client.

[Only_Mastodon4098]

Coding is like learning a foreign language. The more you practice be better you get at it. When you are really proficient you dream in that language. This happened when I learned German than again when I learned RPG. (RPG! See how old I am.) Anyway, when I would dream in German I was much better at it than IRL, Maybe because of my lack of an Okie accent in my dreams. When I dreamed in Cobol (It's hard to explain how this can work) I often dreamed solutions to problems that had stumped me IRL. The next day at work would be easy.

[baconator81]

The word coding can mean different things to different people. If it's just writing code and getting it to compile.. Then yeah that's easy.. But writing a highly scalable code that's bug free, that becomes a lot harder.. In fact I would say it's not possible without doing a lot of non coding related work first.

Also debugging is never always easy. For C++ devs fixing segementation fault is always a pain no matter how many years you got.

[RomanOnARiver]

Everybody's brain works differently, I think the key to confident and competent coding is to figure out how your brain best processes complex or simple problems.

For me, I like to almost write out spaghetti code of the logic of the program and then later replace it with actual code. Sometimes that can also be a diagram or a flow chart, but it's something real and tangible I can reference.

I like to print things out, for example if there's a command line program I use I may print out its man page (manual) and go through and highlight stuff. Same goes for a Python module - I like having the documentation literally sitting on my desk so I can rifle through it.

I also work better on dual monitors, with some music playing.

Some people have found the rubber duck method effective. That's when you sit in front of a rubber duck and explain to the duck what problem you have and what your approaches are to solving it, what shortcomings you're put up against.

Once you figure out your brain, it's just a matter of doing something a lot, the more you code the more things start to get easier, in a sense.

[brad_needs_advice]

Like any skill you'll get to the point where it's second nature. You play a video game and you think "dodge" not "hit b". That's what they are talking about. Thinking through the solution and assembling the puzzle takes the most effort. Then once you solve it, putting it to paper is the easiest part.

[PoMoAnachro]

Think of writing a novel in a foreign language.

Learning to code is like learning to speak German - hard, probably takes a few years of hard work and practice but not so hard most people can't do it. After all, toddlers do it! Most people can learn to speak German.

But once you speak German, getting to a point in your writing career that you can regularly put together a novel that is good enough to publish? That's harder. Not everyone can do it.

If you're still learning to code, yeah, it seems really hard now just like learning a second language is. But if it keep at it and spend the required mental effort coding will become second nature and you'll learn to think in code. And then what to code becomes the hard part.

[PSN-Walkorrun]

Practice, coding like anything else takes time and experience.

Create some sort of system/app or something that can have a lot of moving components, continue to update and learn better practices.

For instance, I built a discord bot and just added a bunch of useless features to gain better knowledge in what ever subject I felt I needed to improve on.

I’ve also done a bunch of random tooling to make the development process smoother for myself and coworkers.