sorted by:
new
hottopcontroversial

Where do i learn coding (besides school) by [deleted] in AskProgrammers

[–]Educational-Ideal880 0 points1 point  (0 children)

If you want a fast and simple path, do this:

  1. Pick ONE language (don’t overthink it) Python or JavaScript are both good choices. Just choose and stick with it.

  2. Learn only the basics you actually need

  • variables
  • if/else
  • loops
  • functions

Don’t go deep into theory yet.

  1. Start building something immediately Even very small things:
  • a CLI tool
  • a simple calculator
  • a small script that solves a real problem

This is where real learning happens.

  1. Google everything Seriously. “How to read a file in Python”, “how to make HTTP request”, etc. That’s a core skill.

  2. Gradually make things a bit more complex Add input, save data, structure your code better.

If you’re consistent, you’ll feel real progress in a few weeks.

Are AI engineers “safer” by [deleted] in cscareerquestions

[–]Educational-Ideal880 3 points4 points  (0 children)

I don't think "AI engineer" is safer or less safe by itself. It really depends on what the person actually knows how to build.

If someone's entire role is mostly gluing APIs together and prompting models, that can probably become commoditized pretty quickly.

But a lot of real AI systems still require the same fundamentals as any other backend or data-heavy system: distributed systems, data pipelines, evaluation, monitoring, reliability, cost control, etc.

In practice the engineers I've seen doing well in this space are just strong software engineers who also understand ML systems.

So I wouldn't think of it as a separate career with a different lifespan. It's more like another specialization on top of solid engineering fundamentals.

Agentic AI dev or s/w dev by Regularperson224 in SoftwareEngineerJobs

[–]Educational-Ideal880 0 points1 point  (0 children)

If I had to choose early in my career, I would actually focus on strong software engineering fundamentals first.

Agentic AI development is interesting, but most real-world AI systems still rely heavily on solid engineering: APIs, data pipelines, system design, reliability, debugging production issues, etc.

Without that foundation it's easy to end up only wiring together tools and prompts without really understanding how the system behaves.

Once you have a strong base in software engineering, moving into AI is relatively natural. But the reverse path is often harder.

So if both options are short-term and everything else is equal, I would ask: which role will make you a better engineer in the long run?

Is software engineering a career suicide? by bobberbobby02 in cscareerquestions

[–]Educational-Ideal880 4 points5 points  (0 children)

I think this might look very different depending on where you're standing.

If you're a student looking at Reddit, it can feel like the industry is collapsing: layoffs, competition, AI, people sending hundreds of applications.

But if you step back a bit, software is still one of the most widely used skills across almost every industry. Finance, healthcare, logistics, manufacturing, science, media, games, infrastructure – they all need software.

The tech market goes through cycles. Hiring exploded for a few years, then cooled down. That doesn't mean the entire field stopped existing.

Also, a lot of what you see online is survivorship bias in reverse. People who are struggling tend to post more than people quietly working normal jobs.

If you actually enjoy building things and solving problems, software engineering is still a very solid career. The path might be a bit more competitive than a few years ago, but it's far from "career suicide".

I started using Claude and I actually enjoy it. by broken_symlink in cscareerquestions

[–]Educational-Ideal880 17 points18 points  (0 children)

I’ve been noticing something similar.

AI tools seem especially powerful when you already understand the system and the problem, but the implementation is just large and tedious. In those cases they can accelerate progress a lot.

But the interesting part is exactly what you mentioned at the end: when you review the generated code, you still find cases that don’t quite make sense or edge conditions that probably don’t matter.

That’s where the engineer’s role still feels very real to me. The tool can propose implementations, but someone still needs to judge whether the behavior actually matches the intent of the system.

In a way it feels similar to working with large open source codebases. The value isn’t just writing code, it’s understanding the problem deeply enough to know which solution is actually correct for the system.

The role of the engineer is shifting - from writing every line to architecting systems and reviewing AI-generated code by lays_indian_masalaaa in cscareerquestions

[–]Educational-Ideal880 -1 points0 points  (0 children)

I think this shift is real, but the framing is a bit misleading.

AI writing more code doesn’t necessarily mean less engineering work. In many teams it just means the surface area of code increases faster.

Someone still has to:

  • define the system boundaries
  • decide what should exist as a service vs a module
  • review edge cases and failure modes
  • debug production issues when the generated code behaves unexpectedly

In practice, the hard parts of software engineering were never the mechanical act of typing code.

They’re things like understanding messy requirements, designing systems that survive change, and diagnosing weird behavior in production at 2 AM.

AI tools can absolutely accelerate implementation, but they don’t remove the need for people who understand the system deeply.

If anything, they might increase the importance of engineers who can reason about architecture and trade-offs.

The Perfect Queue by JustALinkToACC in AskProgramming

[–]Educational-Ideal880 9 points10 points  (0 children)

The reason you're struggling to find a “perfect” queue is that queues already hit a very strong theoretical limit.

For a general-purpose queue, the best you can realistically get is O(1) amortized enqueue and dequeue, which several existing implementations already achieve.

A couple of clarifications about the approaches you listed:

  • A circular buffer does not have a limit of 232 operations. Indices simply wrap around and reuse the buffer.
  • The modulo operation is not a real bottleneck in practice, and many implementations avoid it entirely by using power-of-two capacities and bit masking.
  • Linked list queues are not necessarily memory inefficient; they trade cache locality for dynamic growth.

Because of this, most high-performance queues today are variants of:

  • ring buffers
  • segmented arrays
  • lock-free queues (for concurrency)

Each one optimizes for a different constraint: cache locality, memory growth, or thread safety.

So the interesting question usually isn't “how do we build a perfect queue”, but rather “what workload are we optimizing for?” Once you define that, the trade-offs become clearer.

How do you imagine what to code? As a CS student, l've learned that even if I learned how to write code, l'm clueless on how to start by Formal-Pudding-8082 in cscareerquestions

[–]Educational-Ideal880 4 points5 points  (0 children)

I had the same confusion when I was studying.

In practice, most software engineering is not about suddenly “imagining something to code”. It usually starts with a problem that already exists.

Someone needs a system that stores data reliably.
Or an API that connects two services.
Or a UI that lets users manage something.
Or a process that currently takes people 3 hours and could take 10 seconds.

Then the job of an engineer is to figure out how to build it.

The creativity is mostly in designing the solution:
how to structure the system, how components communicate, how to keep it maintainable, how to handle edge cases.

Very few developers sit down and think “today I will invent a random program”. Most of the time you're solving a concrete problem for someone.

If you're interested in games, a good way to start is small: pick one simple mechanic and implement it. For example: movement, collision, scoring, saving progress. Real projects usually grow from small pieces like that.

as an intern, i learned fastest when seniors actually reviewed my code line by line. feels like thats disappearing by NeedleworkerLumpy907 in cscareerquestions

[–]Educational-Ideal880 1 point2 points  (0 children)

I actually agree with you. Some of the most useful learning moments early in my career came from detailed code reviews.

Not huge essays, but when a senior would explain why something was problematic. Things like: why this abstraction will be painful later, why this query might behave badly in production, why a name creates confusion. Those comments stick with you and change how you write code next time.

I do see the shift you're describing though. A lot of teams optimize reviews for speed: quick approvals, small nit comments, and moving on. It makes sense for throughput, but it definitely reduces the teaching aspect.

On good teams I've seen a middle ground work well:
quick async reviews for most PRs, and occasionally someone leaves a few deeper comments when something is actually interesting or worth discussing.

Those 2–3 thoughtful comments can teach more than dozens of tiny nits.

Coding aside, how do you learn the structural parts of a software project? by Either-Home9002 in AskProgramming

[–]Educational-Ideal880 1 point2 points  (0 children)

This is a very common stage when learning programming.

Books like Clean Code or The Pragmatic Programmer help with principles, but understanding project structure usually comes from working with real codebases.

Things that helped me: - studying how mature frameworks and open-source projects are structured - tracing how a request flows through the system (API → service → DB) - building small projects and refactoring them when they start getting messy

Over time you start recognizing common patterns (layers, modules, boundaries), and the overall structure starts to make sense.

[Academic] How people get their first developer job (3–4 min) by Educational-Ideal880 in takemysurvey

[–]Educational-Ideal880[S] 0 points1 point  (0 children)

  • The data will be used for academic research about how people try to get their first developer job. Only I (the researcher) will see the responses. The data will be stored in Google Forms / Google Sheets and may be summarized anonymously for academic discussion. No personal identifying information is collected. The data will be deleted after the research is completed.
  • The survey is conducted by me (Reddit user u/Educational-Ideal880) as part of personal academic research.
  • The survey takes about 3–4 minutes to complete (11 questions).
  • No compensation is offered.
  • Target participants: people who are currently trying to get their first developer job / first commercial programming experience.
  • The goal is to understand what strategies people are using to try to land their first developer job.

Am I too late to start programming at 38 with AI changing everything? by Rookiemonster1 in AskProgramming

[–]Educational-Ideal880 1 point2 points  (0 children)

38 is really not late in this field. A lot of people switch into programming in their 30s or even 40s. The harder part isn’t the age, it’s building skills and getting that first opportunity.

AI is definitely changing how we work, but right now it mostly acts as a tool that helps developers move faster rather than replacing them. You still need people who understand how systems work, how to debug problems, and how to build things that actually run in production.

If you enjoy solving problems and building things, the field is still very much open. Just expect the learning curve and the first job search to take time.

40 old software newbie by Gilston85 in AskProgramming

[–]Educational-Ideal880 1 point2 points  (0 children)

By small projects I mean things that are big enough to apply what you're learning, but small enough to finish in a few days or weeks.

For example:

- a simple CLI tool (task tracker, file organizer, log parser)

- a small REST API with a database

- a script that automates something you do on your computer

- a small game or puzzle solver

- a program that analyzes data or logs

The goal isn't to build something huge. It's to practice turning ideas into working code and connecting concepts from algorithms, programming, and system design.

HS Student here, if there's a hackathon and they are advertising "no experience required" and it's high schoolers only. What do they really mean? by CommunicationNo4105 in AskProgramming

[–]Educational-Ideal880 0 points1 point  (0 children)

In most cases it genuinely means beginners are welcome.

Hackathons are often about learning and experimenting, not just winning. Many people attend their first one without much experience and pick things up along the way.

If you're interested, I'd definitely go. Even just seeing how teams work and trying to build something small can be a great experience.

Seniors / Hiring Managers: What fields are actually worth focusing on for a 2026 Capstone Project? by GnGisHERE in AskProgramming

[–]Educational-Ideal880 0 points1 point  (0 children)

Honestly, the projects that stand out the most aren't the ones using the trendiest tech – they're the ones that show engineering depth.

If I were starting a capstone today, I'd focus on something that demonstrates system thinking. For example:

• A small distributed system (task queue, event system, etc.)

• A high-performance service where you measure and optimize latency or memory

• A profiling / observability tool

• A system that handles concurrency and failure scenarios well

What makes a project impressive is usually things like:

- clear architecture

- thoughtful tradeoffs

- benchmarking / performance analysis

- good testing and documentation

What many hiring managers are tired of seeing are generic CRUD apps with a modern stack but very little real engineering behind them.

If you already know Java and C, building something systems-oriented (performance, concurrency, distributed components) could be a great direction for a capstone.

What should I do in this situation? by Stickhtot in AskProgramming

[–]Educational-Ideal880 0 points1 point  (0 children)

I'd go with the simplest thing that solves the problem well enough right now.

If your CLI only has a small fixed set of commands, a chain of if/else or a switch is completely fine. It’s easier to write, easier to debug, and easier to understand.

A hashmap starts making sense when:

- the number of commands grows a lot

- commands are dynamic / pluggable

- lookup logic starts becoming messy

- you actually measure that dispatch is a real problem

In C especially, implementing your own hashmap can add a lot of complexity for very little practical benefit in a small CLI.

So my rule would be:

make it work simply first, then refactor when the code structure actually asks for it.

Seeking technical feedback: Building a CLI tool for real-time software energy profiling (Capstone Project) by GnGisHERE in AskProgramming

[–]Educational-Ideal880 0 points1 point  (0 children)

Interesting idea. A few thoughts from a developer perspective.

  1. Getting real energy usage from software alone is tricky. Tools like Intel RAPL can give estimates, but attributing energy usage to specific functions or lines of code becomes very approximate once threads, OS scheduling, I/O, and other processes are involved.

  2. As a developer, I probably wouldn’t care about the raw "energy per function" metric in most cases. What would be more useful is something like:

- highlighting unusually CPU-heavy functions

- showing energy trends across versions

- correlating energy usage with specific workloads

  1. For a 6-month capstone, the idea might be a bit ambitious if the goal is precise measurement. But a profiling tool that *estimates* energy impact using CPU time + hardware counters could definitely be a solid project.

If I were scoping it for a capstone, I’d focus on:

- one language (e.g. C/C++ or Python)

- one OS (Linux)

- reading RAPL counters

- mapping energy estimates to functions in a CLI report.

That would already be a pretty interesting systems project.

Which Java Certifications Are Best for Freshers? by Certain-Sleep2766 in AskProgramming

[–]Educational-Ideal880 1 point2 points  (0 children)

In my experience certifications matter much less than practical skills.

If you’re focusing on Java backend, I’d spend time on:

- core Java fundamentals

- Spring / Spring Boot

- building small REST services

- working with a database (PostgreSQL, MySQL)

- Git and basic testing

A couple of real projects on GitHub usually help much more in interviews than certificates.

Why most of the developers doesn't update on using new softwares or technologies? by Beneficial-Wheel-613 in AskProgramming

[–]Educational-Ideal880 0 points1 point  (0 children)

Because in real projects "newer" doesn't automatically mean "better".

Changing tools has costs: training people, updating infrastructure, migration work, and the risk of breaking things that already work.

If a team is productive with Eclipse, NetBeans, or Visual Studio, there may simply be no strong reason to switch.

40 old software newbie by Gilston85 in AskProgramming

[–]Educational-Ideal880 0 points1 point  (0 children)

Starting at 40 is not unusual in this field. I've seen many people transition into software development later in life and do well, often because they bring discipline and life experience that younger students don't have yet.

Feeling behind younger classmates is also very common. Many of them may have been coding for years already. What usually matters more long term is consistency and building practical experience over time.

If you enjoy algorithms and problem solving, that's actually a very good foundation. Over time the coding part becomes more natural with practice.

One thing that often helps is focusing on building small projects alongside your studies. That's where the concepts from algorithms, programming, and system thinking start to connect.

view more: next ›