What separates a beginner, intermediate, and expert programmer?

What separates a beginner, intermediate, and expert programmer?

Attached: 1521049865998.gif (343x324, 3.1M)

a gf

A beginner to intermediate thinks they are hot shit and the smartest person on the team. An expert realises that they don't really know anything even after all these years.

>t. beginner

>beginner
Non-virgin

>intermediate
Virgin

>expert
Has never even seen a woman

the more money you make

This is absolutely false. It's actually the inverse. Autism leads to better code but poor social interactions which lead to worse pay.

beginner
>mostly copy and pastes code from websites, doesn't really grasp OOP, doesn't doc code

intermediate
>throws shit together and if it works then moves on, uses more for i loops, refactors code well, decent grasp of OOP

expert
>realizes most people don't use OOP well, makes as few objects as possible, codes in the simplest and most understandable fashion possible, realizes that all languages have flaws, documents code more than writes code

Your coding skill?

Interview performance

autism

A cardboard cubicle wall.

>intermediate
>uses more for I loops

>t. beginner

>not using map and fold

Writing a compiler.

Attached: terry.jpg (895x1057, 174K)

>not using map and fold

>Not using jge
Pathetic

>beginner programmer
Check out this new framework, it will solve all of our problems.

>intermediate programmer
I'll use whatever to make this work.

>expert programmer
Done.

For instance, experts wouldn't make these dumb questions.

what is a boner

>not hardcoding every loop with if/else
It's like you want your code to be slow. :^)

This is absolutely false. This poster is trying to justify his weakness to fight for higher wage by diagnosing himself with autism.

Attached: implode.png (1278x981, 658K)

Attached: 010110.jpg (1725x852, 449K)

>Beginner
A woman

>Intermediate
A faggot

>expert
A tranny

According to this I'm expert. Empirical observation that this is not a good measurement.

beginner - learns tools
intermediate - learns methodology
expert - learns reasoning and motivation

Beginner programmers:
Write code
Intermediate programmers:
Write code better
Expert programmers:
Implement algorithms they know inside out and backwards.

Digits confirm.

>Beginner programmers:
>Write code
>Intermediate programmers:
>Write code better
>Expert programmers:
>copy paste shit from stackoverflow and github and collect gibs

Attached: dana.jpg (225x225, 6K)

where is the straight white male?

cute whore

in the useless cringe category

Unemployed

1. Knows syntax
2. Knows how to use docs
3. Writes books about programming

> beginner
Pajeet

> intermediate
Chinese

> expert
Improves the syntax of C in a non-niggerlicious way

Attached: Screenshot_20180608-070351_Gallery.jpg (1080x2220, 915K)

Terry is schizophrenic hobo.
inb4
>CIA nigger!!!
But it's true. And we have better things to do than chasing after some hobo who speaks with """god""".

Who is this qt ?

Sorry user, she likes only black men.

Maybe I'm already black

Show us, Jamal

Can't search for black cock online at work

>God Emperor of HolyC
A misogynist

Smol benis = big kode

Yes you can. Just use private browser's session. And wear gloves to hide your fingerprints.

>beginner
can write pong

>intermediate
can write tetris

>expert programmer
can write dwarf fortress

a software engineer that makes more than you

Autism is by definition poor social skills.
And it's called asperger if the IQ is normal

"beginner" means they can't do shit
"intermediate" means they can do everything, even if they have to write really stupid redundant code (if thing == 1, if thing == 2, if thing == 3, so on)
"expert" means they've learned how to program efficiently and they're an elitist about it and get a hard-on for doing things in as few lines as possible.

Beginner:

for (var i=1; i

>>beginner programmer
Thinks that he is a genius. Say that a task is easy as a piece of case.
But end up expending months to write a shitty code with lots os bugs.

>>intermediate programmer
Humble but very competent.
Finish a task faster than expected.

>>expert programmer
Able to hack large corporations or do lots of damage hacking powerful government agencies if he wanted.
99% of programmers never achieve such level.

Not working because of diversity quotas.

Having poor social skills doesn't make you an autist.

>Able to hack large corporations or do lots of damage hacking powerful government agencies if he wanted.
>99% of programmers never achieve such level.
network security professional != programmer

cute whore

Kek, I'm as bad as anyone on this board whem it comes to social interactions, but I negotiated a $500/month pay bump at an internship last year. Just follow the first rule of salary negotiations: Always negotiate.

Did you write the screenplay for Hackers?

Attached: shank.jpg (225x225, 7K)

Yes unironically

>beginner
avoids the documentation
>intermediate
reads the documentation
>expert
writes the documentation

which gnu/linux distro he uses.

#include
for(i=0;i

if u have blue hair and define yourself as a tranny this means u are a good developer

#include
for(i=1;i

>beginner
googles lot and doesn't test
>intermediate
writes test and comments code
>expert
Says that he had no time to write code because he was managing team, going through commits and running in meetings.

> Earnt $0 for his work
> Now earns $500 for his work
good job user

I think it all comes down to your ability to solve real world problems and general programming knowlage.

>beginner
posts on Jow Forums
>intermediate
posts on reddit and hackernews
>expert
posts on Jow Forums

>not hardcoding everything to work how you want regardless of user input

>beginner
Hack away a working solution with a shitload of technical debt.
>intermediate
Use the right tools for the task, maintain the project and keep the documentation up to date.
>expert
Convince manager/boss/client they don't need that and there's a better to get the same results.

Lolis

Attached: expert programmer ub.png (219x207, 57K)

>beginner
Writes proprietary software
>intermediate
Writes open source software
>expert
Writes free software

>beginner
can tinker, most relies on sites to find presolved solutions, applies them and moves on--has an interest in programming, but is insecure with ability to master it, lacks time and resources to pursue, or is busy with other responsibilities to dedicate more towards the goal

>intermediate
more capable of solving solutions without external sources, though will occasionally reach out over obscure and hard to interpret bugs/issues or to find new methods of implementing certain things. More willing to try out new tools and libraries to improve workflow. The vast majority of the Dunning-Kruger effect is found HERE.

>expert
Keeps it Simple Stupid. Prioritizes workflow, understands how to write excellent logic, recognizes that its more important to know this than to know any specific language--as most are the same with only syntactical variations and occassional rule changes. Can work solo or in a team, often is in a position as a lead or architect, is more often on the lookout to mentor a beginner who is a programmer or is working in an area where programming/scripting can have crossover into development. Is generally also the sanity check that many subordinates will come to, to bounce ideas, reign in the crazy or receive a blessing (validation) that they are on the right track. Most recognize that arrogance serves no one and helping many, when time permits, is a better philosophy than throwing them to the sharks and expecting excellence. Also most likely to give you shit over the little things, because they deal with the most complex tasks, client interactions, architectural flips due to client/contract changes, and its the little things that make the days tolerable; getting on their good side and becoming good friends with these kinds of people has immense pay-offs in the future.

>ctrl+f planning
>no results

No wonder you guys suck so much at programming

comfort with C pointers:
uncomfortable = beginner
comfortable = intermediate
horrified beyond function = advanced

The middle one

Straight people don't /really/ exist

Ascended:
for(i=0;i++

god can cure any sickness, because every sickness has to do with that you separated yourself from god (karma from past lifes exist, and it was also teached between christians before it got censored)

>beginner
20-year-old virgin
>intermediate
25-year-old virgin
>expert
30-year-old virgin

Not accurate at all unless enterprise shitfest of garbage Java monoliths

This.

An intermediate tries to be clever, an expert knows where that shit leads to and avoids it at all costs.

>beginner
thinks Python is a great programming language
>intermediate
knows every language is imperfect and hindsight is 90%
>expert programmer
recognizes that under Pythons fancy syntax it's an absolute shitstain and GVR should be shot on sight because he ignored all possible hindsight and holy fuck even JS, Perl and VB are better

beginner

>knows one or two programming languages very well
>thinks he "knows" programming
>can execute the most important bash commands
>optimizations are clueless
>typical quote: "Whoa, I refactored my WordCount.java and saved 5 lines of code!"


intermediate

>knows a few programming languages very well, including it's major libraries
>knows a couple of frameworks for those languages
>has fiddled arround with a bunch of languages to learn new concepts
>does side projects in esoteric languages every now and then to keep his skill sharp
>knows basics about databases, web design and some common algorithms
>has heard about differnt programming paradigms
>knows he "doesn't really know" programming
>uses bash and other core utils often
>optimizations at the right place
>typical quote: "I whish I had time to learn Erlang, the actor modell is so cool!"


expert


>knows a few programming languages like the back of his hand
>knows at least two differnt stacks
>actually uses differnt algorithms and datastructures at the right place
>knows which framework, tooling and programming language is suited for a certain job
>learns new technologies by using them for new projects
>knows which programming language to use for a certain problem, can take the skill level of his team into account
>knows he doesn't know shit about programming
>tries to go get nearer the true source by learning low level shit liek ASM and networking
>never has time for anything
>optimizations only at the bottle necks, knows about trade-offs
>typical quote: "I'm not sure if I should refactor this shit my colleague has written. We'Re getting into serious technical debts here. But we're already short on budget, so fuck it."

Attached: how_to_troll_g.jpg (300x196, 19K)

Unironically the best answer

Sounds like the voice of experience there.

you are full of shit my dude, half of that criteria for intermediate belongs in beginner.

>all these posts ITT saying experts lead teams instead of spending the bulk of their time writing expert-level code
I know y'all are saying that's how it is, but that's not how it should be. Expert programmers should be writing expert-level code; leave the people shit to people people. This is why you get shit/buggy/unfinished code from most big projects; right at the point when the experts can write actual good code, they're forced/expected to manage teams, wrangle others' commits, and other such people stuff. Fuck that; I want projects to output actual good code the first time!

python, dunning-krugerscript, and c

beginner: can use variables to store data like using ints and floats

intermediate: for loops while loops and if and else

expert: else if paradigm, object oriented coding

having experts in charge is how you get shit done in the long run user.
sure the guy could code the whole damn thing on his own, but if you leave him to work with all the retards he'll just end up doing their work as well when they fuck up. if he's in charge, he can go around and tell the others "hey, that's bad practice, fix this shit" and not spend half a month debugging the project later.

>using multiplication (slow) instead of bitwise OR (fast)
>empty character constants
>passing an int to printf for a string format specifier
>beginner detected

Then what's the point of becoming an expert in the first place if you're not going to be spending the bulk of your time writing expert-quality code? Seems like it'd be better to have a broad - rather than deep - knowledge base so you don't have to get stuck with expert-level shit like dealing with people.

>expert-level shit
>dealing with people
Fuck, are the normalfags really right?

Delet

>For instance, experts wouldn't make these dumb questions.

Checked lmao

Practice. Memorization.

One knows he has no idea what he's doing, the other thinks he knows everything, and the third is just kinda winging it.

The other way around actually. Those virgin neckbeards are usually far from expert devs. The actual good ones are getting paid 7 figures in huge companies.

>beginner
writes shit from scratch because he has to prove he's a real programmer now

>intermediate
having written shit from scratch thinks he's the hottest shit now, finally realizes he has nothing to prove anymore so might start copying shit from around, badly

>expert
turns laziness and experience into productivity: copies as much shit as he can from everywhere and puts it together quite nicely

>beginner
Fears the whiteboard.
>intermediate
Uses the whiteboard repeatedly.
>expert
Uses the whiteboard once.

I'm pretty convinced after 15 years of this job that the only good devs are the ones who don't get behind the keyboard until they have been on the clock for two hours or more.

Beginner:
>Interest in anime
>Knows C++ and maybe some pajeet tier language like java or python
>Developed an interest for programming socks

Intermediate:
>Knows C, C++, C#, Java, Cobol, Fortran and is becoming more proficient in haskell.
>Has helped multiple small open source projects and trains some of the new employees at the company where she works.
>Been on hormone therapy for 3 years

Advanced:
>Participates actively in the development of kernels and uploads security patches directly with linus.
>Been living on the silicon valley as a senior engineer for 13 years and drivers a mercedes.
>Has had facial feminization surgery, breast augmentation and lives fully as a programmer (male).
>Changed her name to her favorite anime character, probably called Natsumi or Haruki
>No more programmer socks but proper programmer lingerie with heels and proper female office attire.
>Is currently engaged with chad after cucking his ex gf by stealing him.

Attached: trap programmer 2.png (1106x1600, 1.96M)

This, but unironically.
spbp, truly.

Damn this is an underrated answer.
Works on so many levels.
First off there's the suggestion that better programmers will have jobs when others wont
Secondly, there's the suggestion that all three of them are working in close proximity, separated physically only by a small wall.
kek
kek

> beginner
writes much bad code
thinks about syntax
does not optimize
does not document

> intermediate
writes much good code
thinks about algorithms
optimizes
documents with comments

> expert
writes good code
thinks about design
measures before optimizing
documents with examples