With about 12 years in my primary language I’d say my expertise is expressed in knowing exactly what to Google…

If you step in enough shit you eventually learn to realise when you are about to step in it again. I think the most knowledgeable people are those that have failed the most and found something helpful along the way, seems you are well on your journey so just keep steeping. At some point the abstractions you have control over become unreliable until you understand how they interact with lower level systems and the balance of control comes back because you know know the circumstances in which these abstractions work in your favour.

The more I learn about my language the less I think it matters. Maybe in embedded C you can’t just leave everything to the compiler though.

Better than many, mediocre.

With my coworkers I’ve got a strange ability to pick up any language that tastes like c, and get stuff done. I’m sure I’ve confused our c# guys when I make a change to their code and ask for a code review, because I’ll chase down quality of life improvements for myself. (Generally, I will make the change and ask if I have any unintended side effects, because in an MCU, I know what all my side effects are, multi threaded application?, not at all)

Edit: coming from a firmware view, I’ve made enough mistakes to realize when order of operations will stab me, when a branch is bad because that pipeline hit will hurt, and I still get & vs && wrong more often than I would like to admit.

Knowing the footguns in your language is always useful. The more you know, the less you’ll shoot your foot.

In C in particular, you have to be very cognizant of the tricky ways the language can screw you with UB. You might want to try some verification tools like Frama-C, use UB sanitizers, enable all the compiler warnings and traps that you can, etc. Other than that, I think using too many obscure features of a language is an antipattern. Just stick with the idioms that you see in other code. Take reviewer comments on board, and write lots of code so you come to feel fluent.

Added: the MISRA C guidelines for embedded C tell you to stay with a relatively safe subset of the language. They are mostly wise, so you might want to use them.

Added: is your issue with C or with machine code? If you’re programming small MCUs, then yes, you should develop some familiarity with machine code and hardware level programming. That may also help you get more comfortable with C.

how do you rate yourself in your most used language?

I know things that no human should have to carry the knowledge of

Do you understand the subtilities and the nuance of your language?

My soul is scarred by the nuanced minutia of many an RFC.

in the hope of reducing my imposter syndrome.

There’s but two types in software - those who have lived to see too much…and those who haven’t…yet.

I got pretty good with BASIC back in 1983.

I’ve learned a lot by breaking things. By making mistakes and watching other people make mistakes. I’ve writing some blog posts that make me look real smart.

But mostly just bang code together until it works. Run tests and perf stuff until it looks good. It’s time. I have the time to write it up. And check back on what was really happening.

But I still mostly learn by suffering.

A one out of ten. I consider myself the world’s second worst programmer.

A solid 5.

I’m happy with it too. They still pay me so I must be doing something right. Almost two decades now.

I’d say average.

In every project and in every team, I end up being strong because I fix the hard stuff. I debug better and I deliver mostly bug free code. My code is more efficient and performant than my coworkers most of the time.

That’s gotta count for something.

Imposter syndrome is good for me. Keeps me learning.

Even the creators of languages don’t know their own languages 100%. I wouldn’t even call them the limit. So, I’m good enough in my main language that a lot of code doesn’t surprise me. And I try very hard to write code that others can understand as well when in a team.

Anti Commercial-AI license

I don’t think your question relates to the language as much as to the platform. The language of choice is somewhat irrelevant and what you care about is what actually happens under the hood.

For the likes of java and go you want to have some understanding of what runtime does for the memory allocations and how their GCs work. For python you sometimes end up in the spots where you need to understand what limitations the GIL imposes (even more important now that they are trying to get rid of it). When you run C (or C++ or Rust) on the embedded hardware it really helps to understand what exactly bit flipping does in specific registers and what DMA means for how you write your code.

You don’t really have to know it all. You can absolutely write code without caring about anything of that and I know plenty software engineers that do. Some people write amazing functional things in java without ever questioning what it does to the machines and what resources you need to run it.

If you start questioning it, that will only expand your understanding. It’s not a lateral move from e.g. C to Rust where you need to learn a lot to write your code in a memory-safe way, it’s a movement deeper into the stack and what you learn there will be applicable to any language you use for this stack.

Answering your question: I always feel bad about not understanding some low-level concept. I have stacks of MCU reference docs lying around, printed, highlighted; I have archives with sample code, and hand-annotated CMSIS reversing notes. Embedded world is hard because you can’t just know C and be done with it. You have to know the hardware, too.

Here’s my advice for you. Make notes of things that you learn from people smarter than you. Create a web of those notes and see where your gaps are. Then, work on learning something in those gaps in particular and see if you can make a blog post or something of your own. When you share what you learn you become one of those people with deep understanding that others look up to. There’s always someone struggling with something that you either know or know how to figure it out.

I am very proficient in my primary language, C#.

Writing more context out feels like boasting, so I think I will skip that and go to a summation/conclusion directly.

Knowledge and expertise comes from more than the language. Which you hinted at. The language is only our interface. How is the language represented, how will it transform the code, how will it be run. There’s a lot of depth in there - much more than there is in the language itself.

I learned a lot, through my own studies and reading, studying, projects, and experience. I’m a strong systematic thinker. It all helps me in interpreting and thinking about wide- and depth- context and concerns. I also think my strengths come at the cost of other things, at least in my particular case.

You’re not alone. Most developers do not have the depth or wide knowledge. And most [consequently] struggle to or are oblivious to many concerns and opportunities, and to intuitively or quickly understand and follow such information.

Which does not necessarily mean they’re not productive or useful.

I’m mostly working in Java now. I’m proficient to the degree that I can solve most things without looking for reference online. I think that matters most to me.

What helped me a lot with pushing deeper down into the language innards is to have people to explain things to.

Last week, for example, one of our students asked what closures are.
Explaining that was no problem, I was also able to differentiate them from function pointers, but then she asked what in Rust the traits/interfaces Fn, FnMut and FnOnce did (which are implemented by different closures).

And yep, she struck right into a blank spot of my knowledge with that.
I have enough of an idea of them to just fill in something and let the compiler tell me off when I did it wrong.
Even when designing an API, I’ve worked out that you should start with an FnOnce and only progress to FnMut, then Fn and then a function pointer, as the compiler shouts at you (basically they’re more specific and more restrictive for what the implementer of the closure is allowed to do).

But yeah, these rules of thumb just don’t suffice for an actual explanation.
I couldn’t tell you why these different traits are necessary or what the precise differences are.
So, we’ve been learning about them together and I have a much better understanding now.

Even in terms of closures in general (independent of the language), where I thought I had a pretty good idea, I had the epiphany that closures have two ways of providing parameters, one for the implementer (captured out of the context) and one for the caller (parameter list).
Obviously, I was aware of that on some level, as I had been using it plenty times, but I never had as clear of an idea of it before.

I should know more about what’s happening under the hood.

You’ve just identified the most important skill of any software developer, IMO.

The three most valuable topics I learned in college were OS design basics, assembly language, and algorithms. They’re universal, and once you have a grasp on those, a lot off programming language specifics become fairly transparent.

An area where those don’t help are paradigm specifics: there’s theory behind functional programming and OO programming which, if you don’t understand, won’t impeded you from writing in that language, but will almost certainly result in really bad code. And, depending on your focus, it can be necessary to have domain knowledge: financial, networking, graphics.

But for what you’re taking about, those three topics cover most of what you need to intuit how languages do what they do - and, especially C, because it’s only slightly higher level than assembly.

Assembly informs CPU architecture and operations. If you understand that, you mostly understand how CPUs work, as much as you need to to be a programmer.

OS design informs how various hardware components interact, again, enough to understand what higher level languages are doing.

Algorithms… well, you can derive algorithms from assembly, but a lot of smart people have already done a ton of work in the field, and it’s silly to try to redo that work. And, units you’re very special, you probably won’t do as good a job as they’ve done.

Once you have those, all languages are just syntactic sugar. Sure, the JVM has peculiarities in how its garbage collection works; you tend to learn that sort of stuff from experience. But a hash table is a hash table in any language, and they all have to deal with the same fundamental issues of hash tables: hashing, conflict resolution, and space allocation. There are no short cuts.

I’ve been using Scala professionally for 3 years. I don’t know what I’m doing most of the time because we have a ton of implicites and monads and extension methods. I just know the general idea and can get where I want by reading types.

I’ve been creating a language for fun for nearly 6 years. I often don’t know what’s going on under the hood because it’s somewhat complex. I think this is normal for every language. You don’t have to know everything to be able to use it. You don’t have to write blog posts once a week about the language subtleties you found.

I would give myself a solid 4.2/5 on python.

• I have in deepth knowledge of more than a few popular libraries including flask, django, marshmallow, typer, sqlalchemy, pandas, numpy, and many more.
• I have authored a few libraries.
• I have been keeping up with PEPs, and sometimes offered my feedback.
• I have knowledge of the internals of development tooling, including mypy, pylint, black, and a pycharm plugin I have created.

I wouldn’t give myself a 5/5 since I would consider that an attainable level of expertise, with maybe a few expections around the globe. IMO the fun part of being really good at something is that you understand there still is to learn ❤️

After almost 12~15 years of programming in C and C++, I would give myself a solid “still don’t know enough” out of 10.

1/10 in python. I took a college course or two and enjoyed it.

I think my job requires me to work in too many different areas. So although I can work in several languages and dev stacks, I am probably only a 2 or 3 or less out of 5 in all of them. However, network and server infrastructure, and cybersec/opsec I am probably more in the realm of a 4-4.5.

8/10 Server-side JavaScript

7/10 Ampscript

3/10 SQL

There is something about SQL that I can’t get to click with me. I can run basic queries and aggregation, but I can never get nested queries to work right.

All of these also assume I have access to documentation. Without documentation, all of them are like a 2. 🤷

SELECT
  one.col_a,
  two.col_b
FROM one
LEFT JOIN
    (SELECT * FROM somewhere WHERE something) as two
    ON one.x = two.x

WITH two as (
     SELECT * FROM somewhere
     WHERE something
)

SELECT
  one.col_a,
  two.col_b
FROM one
LEFT JOIN two
ON one.x = two.x

Being proficient isn’t about getting something right the first time, it’s about how easily you recognize something as wrong and knowing how to get the knowledge to fix it. Under that definition I rate myself 5/5 if I’m not trying to be humble or sorry about tiny details.

Good enough to make my own things or mod things.

But not good enough to get a job as a programmer.

After 6 years of seriously using Python regularly, I’d probably give myself a 6/10. I feel comfortable with best practices and making informed design decisions. I have no problem using linting and testing tools. And I’ve contributed to large open source projects. I could improve a lot by learning more about the standard library and some core computer science concepts that inform the design of the language. I’m pretty weak in web frameworks too, unfortunately.

novice still learning everyday

I’ve been writing code for 25+ years, and in tech for 27+.

I’m a novice at all languages still. Even though they tell me I’m a Principal Engineer.

There’s always some new technique or way to do what I want that’s better I’m learning every day. It never stops. The expectations for what I consider to be good code just continues to climb every day.