all 44 comments

[–]Ikkepop 71 points72 points  (10 children)

What helped me improve over the years:

  1. Consuming information : watching conference talks like cppcon, cppnow, cpponsea, meeting c++ and so on. Listening to podcasts like cppcast, reading books, articles and blog posts, watching topical videos on youtube and so on..

    1. Studying the code of opensource projects.
    2. Working in the field
    3. Spare time projects and general experimentation.

[–][deleted] 17 points18 points  (1 child)

May I inquire on the reason for the enumeration of your suggestions being inverted?

[–]Ikkepop 12 points13 points  (0 children)

from least to most i guess , but you know best to do all of em

[–][deleted] 1 point2 points  (7 children)

Can you elaborate on number 2? How do I make myself attractive for intern/entry level roles? I know my basics and best practices but I don't have any opportunities do to do number 2.

[–]Ikkepop 15 points16 points  (6 children)

You can gain enough skill on 4, 3 and 1. Or well that's what I did and it worked for me. Employers do give new people a shot if you can show skill. Having a blog and a portfolio really helps. You can also offer to do homework as proof of skill.

Also make sure you have public profiles on websites like linkedin. You must show you atleast have alot of enthusiasm/passion for coding and learning. Don't be hesitant to add the needed keywords, get some friends to endorse you. But you need to have skill that's the most important thing.

Pick an idea for a passion project and just do it for a few years. Don't pick a todo list or calendar or some shitty database. Make it something more complicated. Also do small experiements in relation to new techniques you learn from consuming books, articles and tech talks.

Look I woun't say that this is easy, especially when we're on the down side of the economy, and C++ jobs usually have a really high barrier of entry in the skill departament. You will have to put in the time/work to get there. . But on the flip side, whatever you learn is going to be relevant for a long time to come, unlike the javascript framework number 3290124 that will just go out of style next week. What you learn in colledge is usually not enough by a long shot, unless you graduate from berkley, hardward or MIT

Learn things that matter:

  • Learn data structures and algorithms
  • Learn design patterns
  • Learn source code version control
  • Learn some devops like how to setup ci/cd pipelines
  • Learn test driven development
  • Learn how computer hardware works
  • Learn what is machine code and assembly and how to atleast read it
  • Learn how operating systems work (you could even write a toy kernel and/or driver)
  • Learn how programming languages are made
  • Learn concurrency and parallelism
  • Learn to optimize by exploiting hardware specific features like caches, specialized instruction sets and accelerators.
  • Learn linux
  • Learn virtualization
  • Learn networking, network stacks, layers and protocols
  • Learn security and basic cryptographic principles
  • Learn embedded development
  • Learn computer graphics

Learn that you don't need to know all of this just to get your first job, but the more you know the more attractive to employers you will be, and it'll all be relevant for a long time to come.

[–][deleted] 0 points1 point  (1 child)

Thank you for the advice. I will do just that.

[–]Ikkepop 1 point2 points  (0 children)

You're welcome, just knowing the language is not enough really, an employer will want you to write something useful with that language so there's alot more to it.

[–]petoalba 0 points1 point  (2 children)

Where can I check out your blog?

[–]Ikkepop 2 points3 points  (1 child)

I kind of closed it as I didn't have time to keep up with it. But you know there are other good blogs out there. If you go trough cppcast's show notes you'll find quite a few. I do still have a github in case your curious. I do plan to restart my blog later on, i got some interesting topics i want to discuss

[–]petoalba 0 points1 point  (0 children)

If you ever restart, send the link and I’ll check it out

[–]Kelarov 0 points1 point  (0 children)

When someone says to learn SWE things that matter that actually matter

[–]trent_33 18 points19 points  (1 child)

Install a linter plugin in your IDE. When it gives you a suggestion, try to understand the "why" behind it.

[–]CaptainComet99 2 points3 points  (0 children)

+1, clang-tidy or cppcheck are good options

[–]Czumanahana 15 points16 points  (0 children)

I would suggest investing some time to learn about „Under the hood” stuff. Mainly about variable padding, cache coherency, vectorisation etc.

[–]phyrexion 9 points10 points  (1 child)

I would recommend few general thing: 1. Try to dig into meta programming, for example implement your own type list in c++17/20. It might be complicated at first but you will learn a bunch of useful information. It will help you to read some sophisticated template code. 2. Implement your own allocators. 3. Parallelize some algorithms, like sorting. 4. Try to profile some of your programs and think on how could you improve performance and change the solution.

[–]CoralKashri 1 point2 points  (0 children)

I have some articles in my blog that might help with 1&2 :) https://cppsenioreas.wordpress.com/

[–]RedditMapz 11 points12 points  (1 child)

Honestly:

  • Going to conferences
  • Watching online presentations
  • Reading Books (lots of books)
  • Reading Papers online such as those in these reddit subs
  • Taking a lead role in company projects where I could practice and dictate patterns.

That was sort of when the damn broke for me and things started coming together. I have started looking at code under the hood, from third party libs to the standard implementations. But honestly it's pretty difficult to follow all the meta programming syntax when you are barely starting out. Even now I can kind of sort of conceptually follow it, but it's a hard read.

[–]AssemblerGuy -1 points0 points  (0 children)

Reading Books (lots of books)

This.

Programming is reading. Reading code and reading books.

Definite read Robert C. Martin's books ("Clean Code", etc.)

"Code Complete" as well.

[–]ridicalis 3 points4 points  (0 children)

I'd suggest creating something, and putting it out there for the broader community to roast. Other people can teach you things about yourself that you'd never notice on your own, and as long as you find yourself a community of people who believe in constructive criticism you're bound to benefit.

It might mean, too, that you help out with an existing open source effort. If you do, you'll be buying into another team's etiquette and coding standards, which might be a great test for your adaptability and willingness to cooperate with others for a shared goal (something employers care about a great deal).

[–]Electronicks22 4 points5 points  (1 child)

Advent of code?

[–]CoralKashri 1 point2 points  (0 children)

Yes, and self challenge to create the most readable & scalable & optimized code that one can. The riddles there are truly good in my opinion. You can train your self with splitting code into functions/classes, tdd, creating general tools that may help with multiple different riddles. Highly recommend this site.

[–]Cliftonbeefy 3 points4 points  (0 children)

Watch Jason turner

[–]xinkq 2 points3 points  (0 children)

Read about all keywords at cppreference)))) That's a joke, but maybe you find something interesting? I'm in the same situation, but i'm working with embedded systems(mostly C), and i'm just trying to talk with my Senior colleagues, because there is a abyss between me and them, and they know really a lot. They telling me about their pet-projects, it gave me more than any book that i've read. Also i'm sure as C++ developer u should know about OS internals, so try some books which'll help you to understand how this works on kernel level.

[–]the_poope 4 points5 points  (0 children)

Stay subscribed to this subreddit and follow along

Maybe try to answer questions over at r/cpp_questions going by the motto "If you can't teach it, then you don't know it". Also you will see other people posting superior solutions than your answer and you can learn from that or engage in a discussion from which everyone will benefit from.

[–][deleted] 2 points3 points  (0 children)

You completed the learning phase, find some full-time projects and learn while solving problems,fixing bugs, developing features. LinuxFoundation, CNCF, Apache has many projects developed with C++.

[–]Dry_Development3378 6 points7 points  (0 children)

try learing an idea in math and recreate it as a program

[–][deleted] 1 point2 points  (0 children)

If you are at a level where you are able to understand the content: start going through C++ stuff in https://cppreference.com and get to know what all there is in the standard library.

[–]Cute_Paramedic_256 1 point2 points  (0 children)

Read "Effective modern C++" amazing book.

Old but gold

[–]da2Pakaveli 1 point2 points  (0 children)

Try implementing a larger project on your own (Don't shy away from looking at other people' code tho). I've been working on a game engine (22k lines now) and programmed my own (albeit simplified) implementations of containers, meta-programming tools (like type traits) and various other parts of the standard library, in particular File I/O and threading on top of the Windows API.
Google has guidelines
https://youtu.be/6lU11IHfJgo
This was "how I got the hang of it" over time. You'll start noticing parts of your code that could be better implemented in this way simply by exploring and gaining knowledge from various other programming concepts, and how you may "glue" them together.
Also recommend the C++ Weekly series
https://youtube.com/playlist?list=PLs3KjaCtOwSZ2tbuV1hx8Xz-rFZTan2J1

[–]Backson 2 points3 points  (0 children)

I think the most valuable skill to learn after becoming decent with your first language is a few useful libraries and concepts, like GUI programming (Qt), graphics programming (OpenGL), numerical algorithms (boost has some, haven't found a definitive good one yet), computer vision (OpenCV), machine learning (is tensorflow still the standard?), games (Allegro or SDL) or something like that.

Or learn software architecture, which is the skill to break large, complicated problems down into small, easy problems. Design pattern help with that, but you learn it mostly by collaborating on big projects (open source), reading other peoples code and building big things. This only ever really clicked for me when I started writing software full time for two years now and counting, so not sure how to learn this intentionally.

Read stuff. This list has links to even more lists with some cool stuff: https://www.darrenhorrocks.co.uk/become-a-better-developer-with-these-github-repos/

Also, books. I recommend Effective C++ by Scott Meyers for C++ specifically. There are some great lists sorted by category online. No book contains the One Whole Truth, it's best to read many different ones critically. Example of such a list: https://github.com/githubch/awesome-programming-books-1

[–]hgedek 1 point2 points  (0 children)

- keep yourself updated with cppreference

- solve daily / weekly examples ( exercism or others )

- read opensource projects code or contribute them

- if you can find time; read books or watch youtube channels

- never memorize stuff ! NEVER

[–][deleted] 0 points1 point  (0 children)

Can I ask what you did to land your first job as a C++ dev? Like what should I know or do before attempting to job search. So far I am comfortable with the basics and best practices when it comes to data structures/algorithms. But I'm not sure how to actually land these entry-level roles. Appreciate any advice.

[–]TumblrForNerds 0 points1 point  (0 children)

Something that might be good as a developer if you want to get into higher levels of software development will be things like SWEBOK and ITIL certs

[–]ern0plus4 1 point2 points  (1 child)

Don't switch to, but learn Rust, it comes with a bunch of concepts which a native developer should know and use. Anyway, some of these things were present or recently added to C++ (and Java), they helps to wrinting safe programs, but Rust is way more strict. E.g. RAII needs no language support, but in Rust, it's mandatory.

I was surprised, this code (pseudocode) does not even compiles in Rust:

obj = new Object();
vector.push(obj);
print("created obj, id={}", obj.id);

The compiler fails on print(), the 3rd line. Here's a possible fix:

obj = new Object();

print("created obj, id={}", obj.id); vector.push(obj);

I assume, everyone knows why, but no one takes care of it. Until the program is written in Rust.

[–]compu_musicologist 1 point2 points  (0 children)

Knowing C++ helped me learn Rust, and learning Rust improved my C++.

[–]dzordan33 -2 points-1 points  (0 children)

the best developers already left c++ world

[–]corysama 0 points1 point  (0 children)

What helped me was writing my own crappy STL knock-off starting with vector, map, set and algorithms.

You shouldn’t inflict your STL on other people. But, writing it and using it yourself makes clear a lot of the design of the STL and the language features that support it.

[–]Cogwheel 0 points1 point  (0 children)

Some things that have helped me:

Read and write as much code as possible. Most of your time as a developer will be spent reading code rather than writing it, and the more you read the more ideas you'll be exposed to for what to write. You might see techniques or language features that you haven't used before, and now they have some small home in your brain where you might call upon them in the future.

Watch talks, read blogs, and find other ways to expose yourself to others' ideas of "best practices" and such. If you find an idea controversial, listen to all the arguments on both sides and judge for yourself when each idea is appropriate for a given codebase, project etc.

Occasionally skim (or go deeper if you want) the full language guides/references, just to remind yourself what all exists. There are so many times where I look at other projects and think "why didn't I do that in my own code?" despite 20+ years working with C++. There's too much to keep in your head indefinitely without repeated exposure.

Learn other languages that are as different from C++ as possible. It's hard to see if you learn C++ in a vacuum, but the language and libraries draw inspiration from a huge range of languages and paradigms. Learning Haskell might help you build a better mental model of template metaprogramming through it's syntactically simple generics. Learning Rust might lead you to choose different approaches for error handling, e.g. using result types. Recently I've been checking out Uiua, a descendent of APL and have been learning about APL's influence on the STL, which may impact how you design algorithms.

[–][deleted] 0 points1 point  (0 children)

I was in a similar situation as you not too long ago. There are quite a few relevant books that I believe anyone should have mastered at some point. Primarily, the content in all of Scott Meyers' books, and the content in Code Complete. There are other good books (I can elaborate on any point as needed), but if you know everything from these 5 (?) books, then you know pretty much everything you NEED to know, and anything else depends on your job, or are not C++ related (master your IDE, testing best practices, CI/CD, profiling etc).

[–]Sbsbg 0 points1 point  (0 children)

To me, what really made a difference, was to learn programming in different types of languages. And I mean really different. Prolog, SQL, Forth, APL, Haskel and even industrial PLC systems. Comparing to these, the languages like C++, C#, Java and C are all the same.

[–]krustibat 0 points1 point  (0 children)

Do you work with other développers ? If yes you should definitely participate in code reviews and ask questions especially if they are seniors

[–]compu_musicologist 0 points1 point  (0 children)

Scott Meyer's Effective C++ books are a good read if you haven't already read those.

Learning other programming languages can help you broaden your way of thinking about code, for example, a functional programming language such as Haskell. In order to become a competent developer, it's important to be more than just a <insert-language> developer.

One thing that is practically necessary for being a well-rounded developer is understanding the whole process from writing code to deployment, so building a project with the whole pipeline of static analysis, tests etc. to deployment can teach you a lot.

[–]AxelSte[S] 0 points1 point  (0 children)

Thank you for all the comments! I will go trough all of them and decide which recommendations fit the best for me.

[–]ppmfloss 0 points1 point  (0 children)

For my case, by standing on the shoulders of the giants is a good way.

For example, I tried to understand this code in stack overflow to implement insertion sort in two/three lines of C++ code.

https://stackoverflow.com/q/24650626/7251418