yourweekly.dev

The AI-Safe Career 1: Developer Jobs

Matei Copot — Wed, 20 Aug 2025 00:00:00 GMT

When GPT-3 was announced in May 2020, the world of software development changed forever.

At least, that’s what several 2025 headlines and big companies are implying[^1]. The reality is that the perception of the impact of LLMs has been much greater than the actual impact of LLMs: they’re complex tools that capture the imagination.

In this series of articles, we will look at available data and expert analyses[^2] to address the fears and misconceptions, by focusing on one aspect at a time.

:::tip[analysis] Busy readers can find my pragmatic and simplified take-aways in these green “analysis” boxes :::

Is AI taking developer jobs?

There's enough confusion about the current state of the market, that it's worth addressing as the first topic. Let's start by dividing the question into smaller ones we can answer more confidently.

Are software developer jobs declining?

Different data sources have different definitions for software developers, what a job is, and in which location. This gives us an idea of general trends, but be wary when comparing figures.

This is a good illustration of the definition problem: in 2003, the U.S. Bureau of Labor Statistics (BLS) started tracking programmers and developers as different jobs. This leads to vastly different curves, with no clear distinction in categorization.

The point of that graph is not that a certain kind of developer is on their way out, but that data needs to be interpreted with context.

The Washington Post also provided graphs with a breakdown of software workers, which paints a clearer picture:

Note that it's a different timescale: 2011-2025. Most of those categories have been stable throughout, with little impact from the release of LLMs or even inflation. The BLS even projects a "Much faster than average employment growth" for software developers, which is great news.

There's other sources indicating the same pattern:

:::quote There are 485k businesses in the IT Consulting industry in the United States, which has grown at a CAGR [Compound Annual Growth Rate] of 1.7% between 2020 and 2025.; IBIS, 2025

IT Consulting in the US - Market Research Report; IBIS, 2025 https://www.ibisworld.com/united-states/industry/it-consulting/1415/ :::

:::quote Europe Job Growth CAGR [Compound Annual Growth Rate]: 6.4% [employees]

Software Development in Europe - Market Size, Industry Analysis, Trends and Forecasts; IBIS, 2025 https://www.ibisworld.com/europe/industry/software-development/200645/ :::

:::quote [...] ICT specialists in employment in the EU generally held out against the effects of the global financial and economic crisis [...] [...] increased by 62.2% during the period from 2014 to 2024, [...] [...] 4.3% between 2022 and 2023 and 4.8% between 2023 and 2024

ICT specialists in employment; Eurostat, 2025 https://ec.europa.eu/eurostat/statistics-explained/index.php?title=ICT_specialists_in_employment :::

It's completely fair to be skeptic of picking 2020 as the start date for reference of growth, because other events (COVID) had a stronger impact on the market than the announcement of GPT-3. The next sections should address that.

Going by high-confidence BLS data, the U.S. had 1,656,880 employed Software Developers in May 2023, against 1,654,440 in <a href="https://data.bls.gov/oesprofile/" title="Computer and Mathematical Occupations > Software Developers">May 2024</a>. That's a 0.1% 1-year decline, within the 0.7% margin of error. Stable in absolute terms, but unusual compared to the typical growth of around 1-5%. There is a reason for that, and it will be evident soon.

:::tip[analysis] Software Developer employment growth has slowed down in the last couple years, but there's been no significant decline. :::

Why securing a job feels tougher

Despite employment being stable, there's much anecdotal evidence that finding a software job feels tough. Why is that?

This is a measurable effect, not just anecdotal:

:::quote 78% of tech leaders struggle to find candidates, just as 74% of developers struggle to land jobs.

HackerRank Developer Skills Report 2025, Insight 6 https://www.hackerrank.com/reports/developer-skills-report-2025 :::

This source appears biased: HackerRank is where many developers practice for interviews, so it might be obvious that people on the platform are having trouble finding jobs.

Yet those numbers are in line with other available data:

:::quote 74% of employers say they are struggling to find the skilled talent they need. [...]
76% [in] Information Technology

Global Talent Shortage; ManpowerGroup, October 2024 https://go.manpowergroup.com/talent-shortage :::

:::quote as of September 2024, the median unemployment duration was about 10.7 weeks (2.5 months) [...] closer to 6 months in tech-heavy sectors

Average Job Search Time for Tech Roles in the U.S. (2024–2025); Anotnio Montano, April 2025 https://www.linkedin.com/pulse/average-job-search-time-tech-roles-us-20242025-antonio-montano-qehve/ :::

The U.S. "computer and mathematical occupations" unemployment rate[^3] was 2.8% in 2024, impressively lower than the 4.1% national unemployment rate: the jobs are there.

It may be partially explained with employment statistics for new developers, as we'll see later, but a more comprehensive answer involves supply and demand:

:::quote 65% of the number of [U.S. software] vacancies in January 2020 (a 35% decrease!)

Software engineering job openings hit five-year low?; The Pragmatic Engineer, 2025 https://blog.pragmaticengineer.com/software-engineer-jobs-five-year-low/ :::

The missing piece is demand in the job market. Even though software jobs haven't gone down, job postings have. The supply of aspiring developers has kept growing, outpacing the demand. When there's more supply (developers) than demand (job postings), employers get to be more picky about who they choose.

We developers have been used to a candidate's market (very high demand) for over a decade. We're now encountering a period of higher resistance (lower demand) for the first time in a long while, it makes sense that it would seem tough.

But that's not the full story. As hinted by the HackerRank report, employers are also struggling to hire developers, meaning there are enough vacancies, and the problem lies elsewhere:

:::quote In 2023, 57.5% of EU enterprises that recruited or tried to recruit ICT specialists had difficulties in filling ICT vacancies. [...]
With 43.24% the lack of applications was the difficulty for filling ICT specialists’ positions most often faced by enterprises in 2023

ICT specialists - statistics on hard-to-fill vacancies in enterprises, 2025 https://ec.europa.eu/eurostat/statistics-explained/index.php?title=ICT_specialists_-_statistics_on_hard-to-fill_vacancies_in_enterprises :::

Lack of applications is, surprisingly, a high share of the problem. Broken hiring practices are also anecdotally a big share of the problem, you hear stories like these very[^4] often:

:::quote A perfect ATS score doesn’t guarantee a human will ever look at [your job application]. [...] The position is already filled internally. [...] [Cover letters] work only when a human ... reads your application. [...] It’s a numbers game with patience, persistence, and a bit of luck. [...] Many [recruiter] calls are ... to show clients they have a “pool,” [...] friends or connections may find it difficult to push referrals.

The Untold Reality of Job Searching in 2025: A Personal Story; Pushpender Bhandari, 2025 https://medium.com/%40pushpender311/the-untold-reality-of-job-searching-in-2025-a-personal-story-18f54ee30304 :::

:::quote up to 21% of job ads may be ghost jobs

Why is it so hard to find a job now? Enter Ghost Jobs; Hunter Ng, Oct 2024 https://arxiv.org/abs/2410.21771 :::

:::tip[analysis] Demand for developers has declined, and new developers keep coming. This leads to a tougher environment, but still plenty of vacancies. :::

Is AI behind the dip?

Reputable analyses are almost unanimous on this one:

:::quote Interest rate changes explain most of the drop. [...]
[Interest rate changes affect] many things across the economy since 2022, including hiring, the steep fall in VC funding, and how many tech startups survive, thrive, or die.

Software engineering job openings hit five-year low?; The Pragmatic Engineer, 2025 https://blog.pragmaticengineer.com/software-engineer-jobs-five-year-low/ :::

The same article also explains why and how COVID and COVID-related interest rate policy changes have been so impactful on it: both in a booming growth until 2023, and the fall after.

You can see a similar conclusion with different data/metrics, by a different team:

:::quote Before the pandemic, software developer salaries grew faster than average. That changed when the Covid-19 recession ended.

The rise—and fall—of the software developer; ADP Research, 2024 https://www.adpresearch.com/the-rise-and-fall-of-the-software-developer/ :::

Unlike the previous sources, the ADP article suggests a continuous employment loss since 2020 based on independent data, but also declares AI a non-factor.

:::tip[analysis] The dip is explained by COVID and COVID-related interest rate policy changes, AI is a non-factor. :::

You can find plenty of articles predicting mass replacement in the future, many implying it's already happening which is verifiably false. They rely on anecdotes and sensational speculative claims, without supporting research.

They often cite new developers, whose opinions -which they are entitled to- are generally uninformed and exaggerated; and CEOs, who have it in their best interest to make a bad and boring trend (inability to maintain personnel due to unfavourable economy, and/or bad/impulsive management) look like a good and exciting event (cost-cutting via AI will bring stocks up).

A good rule of thumb is that when you read them, if you don't have the time or attention span to check every source, at least check that there are external and somewhat reputable sources.

We have pretty good explanations for what happened until now, but predicting the future is more complex and will be tackled in separate articles.

As an early reassurance:

:::quote when developers use AI tools, they take 19% longer than without—AI makes them slower. [...]
even after experiencing the slowdown, they still believed AI had sped them up by 20%.

Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity; METR, 2025 https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/ :::

This is one study of several, but there's varying results. We'll discuss that more in the relevant article.

Because future articles will be mostly focused on AI, and I've already stated AI is not the problem with demand right now, here's a short aside on what non-AI causes mean for the future:

:::quote The Beveridge curve illustrates the relationship between job openings ... and unemployment rate [...] the overall [U.S.] job match relationship returned to its prepandemic position.

How Have U.S. Workers Fared in a Labor Market Reshaped by the Pandemic?; Federal Reserve Bank of St. Louis, 2025 https://www.stlouisfed.org/on-the-economy/2025/aug/how-us-workers-fared-labor-market-reshaped-pandemic :::

The article above is not specifically about software development, but illustrates what is generally happening to jobs post-pandemic, and software development so far is following similar trends. In short, things are returning to normal.

As for tech specifically, here are my reasons for why I speculate a favourable balance will re-emerge:

The field is maturing: long-term-expensive but short-term-cheap broken hiring practices will be fixed
Demand is already showing signs of rebounding and will keep growing: tech as a whole is not slowing down
Supply will lag behind by a few years, but adapt: e.g. those scared of AI will drop out, leaving more jobs for everyone else.

Are dev jobs distinctly affected by AI?

Another way to see whether AI has been replacing software jobs, is by comparing employment trends with careers that are expected to be less affected by AI. So let's have a look.

<dfn>AI exposure</dfn> is defined as overlap with human capabilities, regardless of effectiveness. Software Development has very high AI exposure, although that doesn't mean it is or will be automated.
Read more about AIOE

:::quote Although the unemployment rate for the most AI-exposed workers is indeed rising, it is actually rising even faster for the least exposed workers. [...] It doesn’t look like workers more exposed to AI are changing occupations more than they used to.

AI and Jobs: The Final Word (Until the Next One); Economic Innovation Group, 2025 https://eig.org/ai-and-jobs-the-final-word/ :::

:::tip[analysis] Unemployment is inversely correlated with AI exposure.
Unintuitively: higher AI exposure is linked with higher employment.
You're less likely to find jobs if you switch to less AI-exposed careers. :::

If you're having trouble making sense of it, keep in mind that correlation is not causation. A likely explanation is that there's forces at play that have much stronger impact than AI, and the cards are laid out such that AI-exposed careers are less negatively impacted by those forces.

If you wanted to look for possible AI causation instead, consider what software development is, at its core:

Why do we want programs developed? To make a computer perform a task that would otherwise be assigned to a slower, less consistent, and more expensive[^5] human.

We are automation: employers hire a developer to make a webpage that can be served to millions of people per day, instead of hiring a printing company and tens of thousands of delivery workers.

:::tip[analysis] Even if delivery workers are less AI-exposed than developers, more powerful developers could end up removing more delivery jobs than developer jobs. :::

We are near the top of the food pyramid of jobs. I don't like that the pyramid exists, but it is in our favour[^6].

{/* TODO link to software development comparison article */}

Bonus: how helpful is a degree?

There's many arguments in favour and against heading into software via university. This section is only concerned with finding jobs in this dip of lower demand, regardless of whether AI is behind it, or other factors like salary.

The charts and data below are for all US industries, but computer science is cited as a major factor in all of them.

:::quote While the unemployment rate for those aged 22-27 with less educational attainment has drifted higher, [...] the unemployment rate for recent college graduates has risen [more]

Educated but unemployed, a rising reality for college grads; Oxford Economics, 2025 https://www.oxfordeconomics.com/wp-content/uploads/2025/05/US-Educated-but-unemployed-a-rising-reality-for-college-grads.pdf :::

The wording is not obvious nor conclusive for computer science specifically, but the chart shows how much better off you would be with a degree.

:::tip[analysis] A college degree's impact on your ability to find a software job is small, and getting smaller :::

The report points out that it's a particularly tough time for new entrants in any field. If you're one of them, you might want to give it a read.

In line with the AI-exposure section above, there's some relevant data for graduates:

:::quote recent college graduates majoring in accounting and education see unemployment rates below 2%

The Labor Market for Recent College Graduates – Part 1: No More Jobs?; Encoura, 2025 https://www.encoura.org/resources/wake-up-call/the-labor-market-for-recent-college-graduates-part-1-no-more-jobs/ :::

2% graduate unemployment is very low, so accounting (a field with high AI exposure) could be a good place to go if you were seeking alternatives. Just keep in mind it's in the bottom 6% of careers by satisfaction.

Conclusion

AI hasn't had noticeable impact on software developer jobs.

So far AI is a non-issue, but how about the future? Next up, we'll look at whether AI has been boosting software developer productivity, and give projections for the future.

On top of my over 10 years of experience in the field, this post took approximately 50 hours to research and write. If it captured your interest, check out yourweekly.dev: a service for aspiring and professional developers.

import DividerText from '~/components/DividerText.astro'

[^1]: I will allude to other less reputable articles, but won't link to them. They're easy enough to find on google, without the extra SEO. [^2]: Most of the references will be for US/EU, because that's what we find most data/analyses for. These are reasonable indicators for global trends, at least for the countries where this article is legal to read. [^3]: Some question the effectiveness of unemployment statistics, because it's "based on unemployment benefit collection". That's not the case for BLS data: https://www.bls.gov/cps/cps_htgm.htm#where. Another metric to consider is the participation rate, showing that the number of US job-willing-and-able people is only roughly 1% below pre-covid numbers: https://fred.stlouisfed.org/graph/?g=1hY50 [^4]: Note that this is from 2023, meaning that when demand was at its peak, higher than before covid, finding a job was still unnecessarily tough. [^5]: financially speaking. The price of human labour is not only salary, but also benefits, taxes, hiring, training, and HR/managers. There's metrics in which it's the other way around, such as energy consumption, but that's not the primary concern of businesses. [^6]: until there's nobody left to buy what we're developing, of course. There must be a balance. This occupational pyramid is only in our favour in relative terms: if we get to the point where corporations don't respect the balance and economies collapse, we will feel it. But so will everybody else.

Happiest Careers

Matei Copot — Fri, 24 Oct 2025 00:00:00 GMT

:::quote You’ll spend about 80,000 hours working in your career: 40 hours a week, 50 weeks a year, for 40 years. So how to spend that time is one of the most important decisions you’ll ever make.

80000hours.org Career Guide; Benjamin Todd, April 2016 https://80000hours.org/career-guide/introduction/ :::

You've probably heard that before. At a certain scale, numbers are hard to internalize, so let's compare it with another figure:

:::quote Students across the OECD receive an average of 7 634 hours of compulsory instruction during their primary and lower secondary education

Education at a Glance; OECD, September 2023 https://www.oecd.org/en/publications/education-at-a-glance-2023_e13bef63-en/full-report/how-much-time-do-students-spend-in-the-classroom_258760fe.html :::

The time you spend on your career is roughly 10 times what you spent in compulsory[^compulsory-education] education. Imagine that experience, day by day, 10 times over.

The good news is that, unlike most compulsory education, you can choose different paths for how you're going to spend that time.

The choice

Assuming you don't want to spend those 10 school-lives being unhappy, whether fresh out of school or switching careers, you might want to weigh your options.

We can do this by looking at the options and deciding which one provides the most "value".

For "value", the ideal metric could be "Subjective Well-Being" (SWB), a scientific construct which roughly means "an inner sense of happiness and fulfillment". This is the standard for scientific research on what you might simply call "happiness", or "a good life".

As a software engineer, I'll be focusing on software engineering, but we need some interesting alternatives to compare. It turns out most people want to be pilots, lawyers/policemen, nurses/doctors, and entertainers, so that's what we'll compare with.

:::caution I'm a software engineer, not a psychologist. I invite corrections by reaching out via matei@yourweekly.dev :::

There are several aspects of a career that influence SWB, there are those:

you say have "value" (job security, own schedule, salary),
you act on as "valuable" (interest, work-life balance, salary), and
give measurable "value"

Instinctively, the first two seem like the most important ones, but the only one that really matters is the measurable outcome[^measurable-outcome].

So which aspects of a career do influence our Subjective Well-Being?

Satisfaction

There's plenty of evidence that job satisfaction has significant impact on SWB: it makes sense that to feel good, it would help if you were satisfied with the work.

However, it's hard to find granular enough data on job satisfaction by occupation/career.

Yet occupational group is one of the most important explaining variables of Work Engagement, a significant factor of Job Satisfaction:

:::quote Work engagement is defined as "a positive, fulfilling state of mind that is characterized by vigor, dedication, and absorption" [...] Occupational group and industry were relatively the most important factors associated with work engagement, explaining 68.1% and 17.1% of all the explained variance of the model, respectively.

Who is Engaged at Work? A Large-Scale Study in 30 European Countries; 2019 https://www.wilmarschaufeli.nl/publications/Schaufeli/513.pdf :::

Your occupation/industry explains around 85% of how fulfilled you will feel with the work.

According to that study, "Professionals" is the second best groups to be in, which includes Software Developers, but also doctors, lawyers, and researchers[^work-engagement-pilots], so it doesn't narrow it down among other top careers. The group "Managers" takes the top spot.

So the best we can do is non-academic data, which is more likely to be biased, have inconsistent definitions, or have problematic methodology. But we work with what we have!

unstandardized data

Here are some sources in no particular order:

:::quote Jobs with the highest job satisfaction in 2024: <ol> <li style="list-style-type: none">[...]</li> <li value="3">Software Developer - with an overall rating of 3.86 out of 5</li> <li style="list-style-type: none">[...]</li> <li value="10">Physicians - with an overall rating of 3.69 out of 5</li> </ol>

The careers that make Americans happiest, based on 750k employees; career.io, 2024 https://career.io/career-advice/careers-that-make-americans-happiest :::

<details> <summary>expand analysis</summary>

3rd best overall, that sounds nice! Data scientist (which I consider a form of software developer) is 1st by happiness among high-paying.

Categories come from the top 50 occupations with highest employee count according to BLS, which is great[^specificity-problem]. But they use the average rating on Glassdoor as the metric for happiness, a method which has many problems, but there is positive correlation

Doctors are 10th in that list, as "Physicians". Pilots, lawyers are nowhere to be found, but this is more likely to be because they don't make the cut of top 50 occupations by employee count, than a significant result. </details>

:::quote [Job satisfaction] Physicians: 80% Commercial Pilots: 77% Lawyers: 68% Computer Software Engineers, Applications: 57%

The Most and Least Meaningful Jobs; Payscale https://www.payscale.com/data-packages/most-and-least-meaningful-jobs/full-list :::

<details> <summary>expand analysis</summary>

A satisfaction of 57% is in the bottom 22% of occupations in their list, with median satisfaction of 68%. Not very good.

Unlike the previous article, very specific occupations like "boilermakers" and "slot key persons" bloat the list, pushing software development down. They also don't give any indication on how they got these numbers: for all we know, all of these have a sample size of 1.

In this list, lawyers have 68% satisfaction, pilots 74-77%, and physicians 80%. All significantly above computer programmers, which are all lumped into one category </details>

:::quote [self-rated happiness:] [pilots: 3.6/5 (top 15%)] [doctors: 3.4/5 (top 34%)] software engineers: 3.2/5 (bottom 46%) [lawyers: 3.0/5 (bottom 7%)]

Are software engineers happy?; CareerExplorer.com https://www.careerexplorer.com/careers/software-engineer/satisfaction/ :::

<details> <summary>expand analysis</summary> That's somewhere in between bottom 22%, and 3rd best from previous articles. Sounds alright, but not very positive.

As for other careers, the order is very different than those in previous articles, and by a wide margin

The story changes if we filter by "attainable careers", where JavaScript developer is 4th best out of 121, and Web Developer is 13th overall. But we can't cherry-pick like that: pilots, lawyers, and doctors are not in these 121 "attainable" jobs, and neither is software developer as a whole. You do find some healthcare workers. </details>

:::quote [...] 17 popular jobs with the highest job satisfaction rates[:]

Physician
Software engineer
Software developer [...] <li value="11">Flight attendant</li>

17 of the Happiest Jobs (With Duties and Salary Information); Jamie Birt, Indeed https://www.indeed.com/career-advice/finding-a-job/happiest-jobs :::

<details> <summary>expand analysis</summary> Not only is software the second best by satisfaction, it's also the third best!

This again highlights the specificity problem[^specificity-problem], those should not count as separate. They also got their data from Glassdoor, but ended up with a significantly different order compared to the career.io list. They don't explain it, but the reason seems to be that they sort by salary

Pilots and lawyers didn't make the list, but flight attendants are 11th, and doctors are 1st. </details>

It's inconsistent: software development does rank very well, often above the other careers we mentioned, but sometimes below.

I mentioned that occupation has a strong effect on job satisfaction, yet we don't see significant differences among these already high-satisfaction jobs.

:::tip[summary] The average satisfaction difference is not between software and the reference careers, but between software alongside the relevant careers, when compared with e.g. freight handlers and parking lot attendants[^elementary-occupations]. :::

interest fit

That doesn't mean satisfaction is irrelevant when picking between these careers, only that average satisfaction won't help in choosing between the ones we're comparing with.

We still have some useful metrics:

:::quote Results revealed a statistically significant, positive relation between interest fit and overall job satisfaction

Interest Fit and Job Satisfaction: A Systematic Review and Meta-Analysis https://www.researchgate.net/publication/344755247_Interest_Fit_and_Job_Satisfaction_A_Systematic_Review_and_Meta-Analysis :::

If you're interested in the work, your job satisfaction is likely higher. This study claims a correlation of 0.2: not a strong effect, but definitely a noticeable one.

Intuitively, that makes sense: if you're interested in tech, mathematics, or games, you're more likely to be happy if you're a software developer than someone who isn't. But if you're just looking for a job for the money, and aren't at all interested in these topics, you can still be a satisfied developer.

:::tip[summary] There's no significant difference in average satisfaction between devs, pilots, lawyers, and doctors.
You should pick the one you're most interested in. :::

Salary

Work is not only about having purpose and feeling good, it's also about having capital to spend on the other joys and needs of life.

For developers, this is not a contested metric. But let's check our assumptions.

:::caution I'm a software engineer, not a statistician or economist. I invite corrections via matei@yourweekly.dev :::

I took the best data available (BLS OEWS, May 2024), and compiled a quick and dirty google sheet to make it easier to explore.

:::quote [median wage by occupation in $/hr:] <ol> <li value="1">Family Medicine Physicians: 114.61 $/hr</li> <li value="19">Lawyers: 72.67 $/hr</li> <li value="41">Software Developers: 63.98 $/hr</li> </ol>

Occupational Employment and Wage Statistics Query System OEWS; U.S. Bureau of Labour Satistics, 2024 https://data.bls.gov/oes/#/industry/000000 :::

Where are pilots? BLS leaves pilot data blank, because it doesn't keep track of values above 115 $/hr, so it would be above physicians[^pilot-salary].

To further bring developers down, the US is known to give disproportionately high salaries, so this is not globally representative.

At first, developer salaries seem to be the worst of those 4 occupations, but that's not the end of the story: those categories are quite narrow, there's many different kinds of doctors, lawyers, and programmers.

It makes sense that a neurosurgeon earns more than your average developer: looking at narrow definitions only gives you an idea of a "maximum" for each field, it's not a good indicator of what going for that career path might look like. So let's zoom out a little:

:::quote [median wage by occupation in $/hr:] <ol> <li value="2">Computer and Mathematical Occupations: 50.89 $/hr</li> <li value="3">Legal Occupations: 48.07 $/hr</li> <li value="5">Healthcare Practitioners and Technical Occupations: 39.95 $/hr</li> <li value="16">Transportation and Material Moving Occupations: 20.55 $/hr</li> </ol>

Occupational Employment and Wage Statistics Query System OEWS; U.S. Bureau of Labour Satistics, 2024 https://data.bls.gov/oes/#/industry/000000 :::

Development related jobs are the "Computer and Mathematical Occupations" category. It might seem broad from the name, but it's a very reasonable grouping. It's relatively easy to jump between occupations in this group.

What we see is that the order has flipped! The category for pilots is at the bottom, then doctors, then lawyers, then developers at the top, just before management professions.

That's because, while the category for developers is representative of developers, pilots are in the same category as taxi and bus drivers. To a lesser extent, this same effect is seen in lawyers and doctors.

If there is such a thing as a true ranking[^true-ranking], it's somewhere in between the two lists.

An important take-away is that by entering software engineering, you're almost guaranteed a high-paying salary, while you can't say the same for the other fields. A small fraction of people that intend to become e.g. doctors, become doctors, while it's hard to fail as a software engineer[^fail-in-career].

The graph is sorted by median (blue), which is more representative of the average career, and in this category it's the second best overall, much higher than the national median of 23.80$/hr BLS gives. By average (red), we get a similar result at 56$/hr, well above the national average of 32$/hr.

You'd be doing a lot better than most people in your country, if you live in the US. Whether that's twice as rich or three times as rich might not end up mattering, it's a choice only you can make.

If instead you're driven by ambition, consider that, normally, senior google developers (L5) make ~200 usd per hour. That's much higher than the median physician, and an attainable position if you're dedicated.

:::tip[summary] The highest doctor salary is higher than the typical developer salary. The median developer's is higher than the median healthcare worker's. How you want to compare depends on you. :::

starting salary

Even though software development is high-paying, I recommend some level of humility, at least for the next few years while we recover from the economic effects of COVID.

Your starting salary won't be the median salary, but remember to compare that with the starting salaries of other occupations. According to BLS data, at least 75% of employed in the category make 36$/hr, which is more than what ~75% of all U.S. employees make.

This is again hard to compare with the other careers we mentioned, because e.g. the bottom 25% of earning doctors have already gone through 11-16 years of training, while the developer they're being compared with might have been on the job for 1 year, and not attended university.

In practice, for the other careers, the comparable starting salary is negative and steep!

initial costs

:::quote [...] the average price of an undergraduate degree and medical degree [is] a whopping $364,536

How Much Does It Cost to Become a Doctor?; TJ Porter on The White Coat Investor, 2023 https://www.whitecoatinvestor.com/average-cost-to-become-a-doctor/ :::

:::quote The average total cost of law school is $217,480.

Average Cost of Law School; Melanie Hanson on educationdata.org, 2025 https://educationdata.org/average-cost-of-law-school :::

:::quote It costs $105,000 to [be licensed as an airline] pilot if you’re starting with zero experience

How Much Does it Cost to Become a Pilot?; thrustflight.com https://www.thrustflight.com/cost-to-become-pilot/ :::

:::quote A bachelor’s degree in computer science costs $15,000 to $60,000 for on-campus programs

Is a Computer Science Degree Worth It for 2025? Imed Bouchrika, Phd on research.com https://research.com/degrees/is-computer-science-degree-worth-it#:~:text=A%20bachelor's%20degree%20in%20computer%20science :::

But the good news are not over for developers: around 20% of professional developers don't have a bachelor's degree. Unlike the other 3 careers, you can get great software developer jobs with little to no financial investment.

:::tip[summary] Top doctors, pilots, and lawyers earn more than the top developers.
But the expected value (likely salary) of going into software is higher :::

Conclusion

Is that it? These can't be the only factors.

They're not, but they're by far the most significant ones, that you have control over. Job Satisfaction and Salary are the best predictors of Subjective Well-Being.

You spend most of your life at work, and reaping benefits of work. Intuitively, it makes sense that Job Satisfaction and Salary are the main factors.

What about work-life balance and job security?

These and other factors are baked into what is measured in Job Satisfaction. Job Security does play a special role: if it's very hard to get the job, the many that didn't reach their goals are not fully accounted for.

Can you guess which career is by far the easiest to get into, of the ones listed? And no, AI isn't taking developer jobs.

:::tip[summary] Software development is comparable to (if not better than) other highly sought-after careers on most metrics.

The distinguishing factors that affect choice are "interest" and "initial resources/cost". :::

I hope this article was helpful, whether to help reassure you of a choice you've made, or to avoid making choices that will leave you in debt.

:::note[advertisement] Despite not being conclusive or as polished as I'd like, this article took over 100 hours to research and write.

If it captured your interest, you're probably well suited for a career in software development, and you might be interested in starting your own path with my budget-friendly high-value mentoring service: yourweekly.dev.

If you're not sure, you can use the 15 minute free trial and we can chat through your options! :::

import DividerText from '~/components/DividerText.astro'

[^compulsory-education]: I couldn't find a direct source that includes the rest of secondary education. Linearly extrapolating to 12 years gives you 10,178 hours, so a career is 8x the amount of hours. [^measurable-outcome]: When buying a used car, you may say you chose it because 1. it's "a classic", while really you bought it because 2. it had a nice paint job and the salesman seems to like you, but what will predict whether it's a good choice is 3. the mileage and service history. [^work-engagement]: Also a significant factor of SWB by itself [^work-engagement-pilots]: Pilots are in the third best group: "Technicians and associate professionals" [^specificity-problem]: It's great because they didn't try to make their own categories. But it has problems, because BLS data still has specificity problems, see my explanation here. [^elementary-occupations]: "Elementary occupations" was the group least correlated with job satisfaction. I'm sure many of these are happy people, these are indicators of trends in a group, you can't make assumptions about individuals! [^pilot-salary]: Pilots are paid differently and don't fit well into the metric. The actual hourly wage might be as low as 20% of what BLS indicates: https://ctipft.com/how-pilot-pay-works/ . BLS also doesn't include figures for some doctors doctrines because they're too high. "Family Medicine Physician" is not actually the highest-earning according to BLS. I don't account for this in the spreadsheet, and you'll see why it doesn't matter if you keep reading. [^true-ranking]: Which ranking system is "right" depends on many subjective and individual factors, such as how ambitious you are, your initial resources, and your ability to learn. While dreaming of an ideal life sounds nice, very few people get there, and planning for the case that you don't fully get there is the sign of a wise person. [^fail-in-career]: This is a heavy simplification. While the vast majority that set out to be doctors, pilots, and lawyers don't end up achieveing their goal, software engineering also has a steep initial drop-off, to do with discipline and ability to self-learn. But if you're at least a little motivated, and find the right people that can guide you through it, that's much easier to overcome than extreme tuition fees and years of study.

Painting with functions

Matei Copot — Wed, 31 Dec 2025 00:00:00 GMT

import './style.css'

import Editor from '~/components/Editor/index.astro' import DividerText from '~/components/DividerText.astro'

Functions are everywhere in programming. If you're confused by the concept, it makes sense to take some time to understand them now, and save yourself from a lot of pain.

In its simplest form, a function is a reusable sequence of instructions. A label for lines of code.

Instructions

An instruction is the programmer telling the computer to do something.

If you tell your dog to sit, or bark, or shake, that's an instruction.

We'll start with a computer that already knows how to draw simple shapes:

// This grey text is a "comment".
// It's just for you to read, it has
//  no effect on the program.

// This is an instruction! Draw a:
rectangle(100, 200, 150, 250, 'red');
//          x,   y,   w,   h, color

// It says: draw a rectangle:
//  100 pixels from the left (x)
//  200 pixels from the top (y)
//  150 pixels width (w)
//  250 pixels height (h)
//  in red (color)

</Editor>

By the end of the article, you'll be able to make relatively complex paintings using these simple shapes, by combining them using functions.

Let's get to know what instructions we can work with.

Shapes

// rectangle(x, y, width, height, color)
rectangle(100, 100, 400, 100, 'red');

// circle(x, y, radius, color)
circle(200, 300, 50, 'blue');
// x and y specify the center.

// triangle(x, y, w, h, color)
triangle(400, 400, 200, 150, 'green');
// x and y specify center of base.
// w is width of base.

</Editor>

We can draw rectangles, circles, and triangles. What we put in the parentheses is information about where to draw them, and what color.

In the editor above, change the numbers until you understand what they do. Don't continue until you can make the circle fit inside the rectangle!

Composing

What can we do with this? A whole lot!

Let's combine 2 instructions, and draw a tree:

// a trunk
rectangle(280, 300, 40, 100, 'chocolate');

// the leaves
triangle(300, 300, 200, 200, 'green');

// optional:
// - Edit this to make your own tree!
// - E.g. can you add christmas ornaments?

</Editor>

:::tip Click on the top left (where x and y are labeled) to hide/show the grid :::

Looks lonely! Let's make it a little smaller, and add a few more trees:

// left tree
rectangle(290 - 150, 300, 20, 50, 'chocolate');
triangle(300 - 150, 300, 100, 100, 'green');

// center tree
rectangle(290, 300, 20, 50, 'chocolate');
triangle(300, 300, 100, 100, 'green');

// right tree
rectangle(290 + 150, 300, 20, 50, 'chocolate');
triangle(300 + 150, 300, 100, 100, 'green');

</Editor>

See how, to move an exact copy 150 pixels to the right, we just add 150 to the x coordinates (how far to the right it is). We subtract to go left.

Apart from that x-shifting, the rest of the code is the same for all the trees.

Writing the same code with some small variations gets tedious over time: say I wanted 10 trees, that's a lot to write or copy paste!

Generalizing

That's where functions come in: they get rid of this repetitiveness.

Let's start with that center tree:

// left tree
rectangle(290 - 150, 300, 20, 50, 'chocolate');
triangle(300 - 150, 300, 100, 100, 'green');

// center tree. Now a function!
tree();

// right tree
rectangle(290 + 150, 300, 20, 50, 'chocolate');
triangle(300 + 150, 300, 100, 100, 'green');

function tree() {
  rectangle(290, 300, 20, 50, 'chocolate');
  triangle(300, 300, 100, 100, 'green');
}

</Editor>

We turned the center tree into function tree() { ... }, and executed the lines inside it with tree().

We have defined the tree function as drawing a rectangle and a triangle, in a tree layout, just like we did before.

You can see the result is indistinguishable! It's exactly the same picture.

Let's try to replace our other trees, to avoid the repetitiveness:

// left tree (expected)
tree(); // goes in the center instead!

// center tree
tree();

// right tree (expected)
tree(); // goes in the center instead!

function tree() {
  rectangle(290, 300, 20, 50, 'chocolate');
  triangle(300, 300, 100, 100, 'green');
}

</Editor>

That's a problem: the program drew 3 trees, but they're all on top of each other.

The rectangles and triangles for each tree are drawn at exactly the same positions, there's nothing to tell each tree that it should be to the left or to the right (-150 and +150).

The function we created is not very useful if it always draws the tree in the same place. Let's fix that.

tree(-150); // left tree
tree(0); // center tree
tree(+150); // right tree

function tree(offset) {
  // centered on 300 + offset
  rectangle(290 + offset, 300, 20, 50, 'chocolate');
  triangle(300 + offset, 300, 100, 100, 'green');
}

</Editor>

When we define a function, we can declare parameters (sometimes called arguments) to specify variations: changes in the code that will be run.

To know what value to use as the offset, we look at how the function is used, e.g. tree(150) means that:

the offset will be 150, so
290 + offset will be 290 + 150 = 440

And 440 pixels from the left edge is where the rectangle for the trunk of the right tree starts.

The tree function now knows where to put its rectangle and triangle, based on the offset parameter.

Simplifying

It's more intuitive to say "put a tree at x=450" than "put a tree 150 pixels after 300 pixels".

We can make both our function and our usage simpler, by allowing tree(x) to put the tree directly at x rather than 300 + x:

tree(100);
tree(300);
tree(500);

function tree(x) {
  // centered on x
  rectangle(x - 10, 300, 20, 50, 'chocolate');
  triangle(x, 300, 100, 100, 'green');
}

</Editor>

Now tree(100) creates a tree whose center is 100 pixels from the left.

:::note[Why are we subtracting from x?] The reason we have x - 10 is to center the rectangle.

If the rectangle is 20 wide, and we want to center it at 100, that means the rectangle should start at 90 and end at 110.

How do we get to 90 from x = 100? The answer is x - 10.

You'll be seeing a lot of unintuitive code like this when it comes to graphics (drawings). If you're curious, try to reason about how you would do a similar action, write it in code, and see if it matches! :::

And we can do the same for y:

tree(100, 350);
tree(300, 350);
tree(500, 350);

// now we can fit more!
tree(200, 300);
tree(400, 300);

function tree(x, y) {
  // centered on x, rooted at y.
  rectangle(x - 10, y - 50, 20, 50, 'chocolate');
  triangle(x, y - 50, 100, 100, 'green');
}

</Editor>

You can now use tree as an instruction!.

Functions are themselves instructions, and can be used in other functions.

For example, we can make a forest function that uses our new tree function, several times.

forest(350)

function forest(y) {
  tree(100, y);
  tree(300, y);
  tree(500, y);

  tree(200, y - 50);
  tree(400, y - 50);
}
function tree(x, y) {
  rectangle(x - 10, y - 50, 20, 50, 'chocolate');
  triangle(x, y - 50, 100, 100, 'green');
}

</Editor>

This produces exactly the same result as our previous example.

But it's now in a function, which means we can have more fun with less effort!

forest(350)
// more forests!
forest(525)
forest(175)

function forest(y) {
  tree(100, y);
  tree(300, y);
  tree(500, y);

  tree(200, y - 50);
  tree(400, y - 50);
}
function tree(x, y) {
  rectangle(x - 10, y - 50, 20, 50, 'chocolate');
  triangle(x, y - 50, 100, 100, 'green');
}

</Editor>

Imagine how many lines of code that would be if we didn't use functions!

It's 15 rectangles and 15 triangles, all with different positions. It would be a mess:

rectangle(90, 300, 20, 50, 'chocolate');
triangle(100, 300, 100, 100, 'green');
rectangle(290, 300, 20, 50, 'chocolate');
triangle(300, 300, 100, 100, 'green');
rectangle(490, 300, 20, 50, 'chocolate');
triangle(500, 300, 100, 100, 'green');
rectangle(190, 250, 20, 50, 'chocolate');
triangle(200, 250, 100, 100, 'green');
rectangle(390, 250, 20, 50, 'chocolate');
triangle(400, 250, 100, 100, 'green');
rectangle(90, 475, 20, 50, 'chocolate');
triangle(100, 475, 100, 100, 'green');
rectangle(290, 475, 20, 50, 'chocolate');
triangle(300, 475, 100, 100, 'green');
rectangle(490, 475, 20, 50, 'chocolate');
triangle(500, 475, 100, 100, 'green');
rectangle(190, 425, 20, 50, 'chocolate');
triangle(200, 425, 100, 100, 'green');
rectangle(390, 425, 20, 50, 'chocolate');
triangle(400, 425, 100, 100, 'green');
rectangle(90, 125, 20, 50, 'chocolate');
triangle(100, 125, 100, 100, 'green');
rectangle(290, 125, 20, 50, 'chocolate');
triangle(300, 125, 100, 100, 'green');
rectangle(490, 125, 20, 50, 'chocolate');
triangle(500, 125, 100, 100, 'green');
rectangle(190, 75, 20, 50, 'chocolate');
triangle(200, 75, 100, 100, 'green');
rectangle(390, 75, 20, 50, 'chocolate');
triangle(400, 75, 100, 100, 'green');

</Editor>

Not only would it be harder to tell what's going on just by reading the code (are those trees, or pistacho chocolate bars?), but it would also be more time consuming to make changes.

Imagine we wanted to change the color of our tree trunk to brown: we'd have to change 15 lines, instead of just 1 in the tree function!

Hopefully you now understand why functions are in your best interest, even if it seems like an extra step.

Library

To achieve something complex, you want to have a few good functions available.

Sometimes you might find that someone else already wrote some functions for you to use. In programming, we call this a library: a reusable source of knowledge we can leverage.

:::note[You're already using a library] To make this blog post, I wrote a small library for you: rectangle, triangle, and circle are themselves just functions!

You can click on "Open Sandbox" in any of these editors, and open index.html, to see how they are defined.

Precisely because it's a library, you don't need to understand the details, and can simply use the functions as they are. :::

So let's build a library for your drawing needs!

We already have functions for trees and forests, let's add more.

Backdrop

Every painting needs a backdrop.

This doesn't need to be a function, as we only need one backdrop, but "drawing the backdrop" is a reasonable instruction to make our life easier, later.

backdrop();

function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');
}

</Editor>

We drew the sky.

A rectangle that fills the screen: starts at the top left corner (0, 0), and is the same size as the canvas (600 wide, and 500 pixels high).

Or is it an ocean, or a lake? Adding a sun would help clarify that.

backdrop();

function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');
}

</Editor>

Note that the sun circle can go on top of the sky rectangle.

Instructions happen in a sequence, order matters: if you first draw a blue rectangle, and then a yellow circle on top, you can see the yellow circle.

If you do it the other way around, the rectangle covers the circle and you don't see it. You can try it, by putting the rectangle after the circle in the editor above.

Now we just need some surface to put trees on:

backdrop();

function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}

</Editor>

:::note[What are these colors?] If you wonder where I get colors like "chocolate", "aqua", and "olivedrab", you can find the list here.

Feel free to play with other colors, or other color formats. :::

We have a backdrop! Let's see how we would use it.

Adding the trees is as easy as calling (executing) our tree function:

backdrop();
tree(100, 380);
tree(200, 350);
tree(250, 465);

function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}

function tree(x, y) {
  rectangle(x - 10, y - 50, 20, 50, 'chocolate');
  triangle(x, y - 50, 100, 100, 'green');
}

</Editor>

Let's remove the trees for now, and work on another function in our library.

Cloud

Clouds look nice in paintings! Especially when they're all puffy.

A simple way to approximate a puffy shape, is with a few circles:

backdrop();
cloud(150, 150);

function cloud(x, y) {
  // big center puff
  circle(x, y, 20, 'white');

  // small left puff
  circle(x - 20, y + 10, 10, 'white');

  // medium right puff
  circle(x + 20, y + 5, 15, 'white');
}


function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}

</Editor>

That looks nice! A cloud centered on x=150, and y=150

Once we have the function for it, we can add as many clouds as we like, with little effort:

backdrop();
cloud(100, 50);
cloud(150, 100);
cloud(250, 50);

function cloud(x, y) {
  // big center puff
  circle(x, y, 20, 'white');

  // small left puff
  circle(x - 20, y + 10, 10, 'white');

  // medium right puff
  circle(x + 20, y + 5, 15, 'white');
}


function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}

</Editor>

Mountain

The most visually pleasing paintings, in my opinion, are landscapes with mountains.

So here's a simplified mountain: two overlapping triangles.

Let's make a function with it:

backdrop();
mountain(200, 250);

function mountain(x, y) {
  // base
  triangle(x, y, 120, 100, 'saddlebrown');

  // snow cap
  triangle(x, y - 50, 60, 50, 'white');
}


function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}

</Editor>

Once again, now that we have the function for one mountain, we can add multiple mountains!

backdrop();
mountain(200, 250);
mountain(50, 250);
mountain(100, 250);


function mountain(x, y) {
  // base
  triangle(x, y, 120, 100, 'saddlebrown');

  // snow cap
  triangle(x, y - 50, 60, 50, 'white');
}
function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}

</Editor>

This doesn't look great because the mountains are all the same size, but that's a problem for a future article.

If you'd like some practice, see what you can do about it!

hint: add a h parameter to mountain

House

We have methods to draw the sky, a sun, grass, trees, and mountains.

A house would fit well!

This will be our most complex drawing element yet. Let's construct it step by step:

backdrop();
house(300, 300);

function house(x, y) {
  // walls
  rectangle(x - 50, y - 75, 100, 75, 'lightgrey');

  // roof
  triangle(x, y - 75, 120, 40, 'brown');
}


function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}

</Editor>

That's a very basic house, let's add a door and a doorknob:

backdrop();
house(300, 300);

function house(x, y) {
  // walls
  rectangle(x - 50, y - 75, 100, 75, 'lightgrey');

  // roof
  triangle(x, y - 75, 120, 40, 'brown');

  door(x - 15, y);
}
function door(x, y) {
  // door
  rectangle(x - 12.5, y - 40, 25, 40, 'peru');

  // doorknob
  circle(x - 6, y - 20, 3, 'saddlebrown');
}


function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}

</Editor>

Once you have one house, you can have as many houses as you can fit, with little extra effort!

backdrop();
house(300, 300);
house(150, 400);
house(450, 350);

function house(x, y) {
  // walls
  rectangle(x - 50, y - 75, 100, 75, 'lightgrey');

  // roof
  triangle(x, y - 75, 120, 40, 'brown');

  door(x - 15, y);
}
function door(x, y) {
  // door
  rectangle(x - 12.5, y - 40, 25, 40, 'peru');

  // doorknob
  circle(x - 6, y - 20, 3, 'saddlebrown');
}

function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}

</Editor>

All together

We've built a library of shapes to use in a painting, now it's just a matter of drawing the painting we want!

Let's start by drawing one of each shape, so we know what we're working with:

// Our top-level instructions.
// These alone give a good idea about
//  what the program is doing

backdrop();

cloud(100, 100);
mountain(200, 250);

tree(150, 450);
house(450, 350);

// Our function definitions.
// These are "details" on how to implement
//  the top-level instructions

function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}
function cloud(x, y) {
  // big center puff
  circle(x, y, 20, 'white');

  // small left puff
  circle(x - 20, y + 10, 10, 'white');

  // medium right puff
  circle(x + 20, y + 5, 15, 'white');
}
function mountain(x, y) {
  // base
  triangle(x, y, 120, 100, 'saddlebrown');

  // snow cap
  triangle(x, y - 50, 60, 50, 'white');
}
function tree(x, y) {
  rectangle(x - 10, y - 50, 20, 50, 'chocolate');
  triangle(x, y - 50, 100, 100, 'green');
}
function house(x, y) {
  // walls
  rectangle(x - 50, y - 75, 100, 75, 'lightgrey');

  // roof
  triangle(x, y - 75, 120, 40, 'brown');

  door(x - 15, y);
}
function door(x, y) {
  // door
  rectangle(x - 12.5, y - 40, 25, 40, 'peru');

  // doorknob
  circle(x - 6, y - 20, 3, 'saddlebrown');
}

</Editor>

Now we can re-use them and lay them out as needed.

backdrop();

cloud(100, 50);
cloud(150, 100);
cloud(250, 50);

mountain(200, 250);
mountain(50, 250);
mountain(100, 250);

tree(70, 380);
tree(210, 360);
tree(130, 420)
tree(250, 465);

house(450, 350);


function backdrop() {
  // sky
  rectangle(0, 0, 600, 500, 'aqua');

  // sun
  circle(500, 100, 30, 'yellow');

  // ground/grass
  rectangle(0, 250, 600, 250, 'olivedrab');
}
function cloud(x, y) {
  // big center puff
  circle(x, y, 20, 'white');

  // small left puff
  circle(x - 20, y + 10, 10, 'white');

  // medium right puff
  circle(x + 20, y + 5, 15, 'white');
}
function mountain(x, y) {
  // base
  triangle(x, y, 120, 100, 'saddlebrown');

  // snow cap
  triangle(x, y - 50, 60, 50, 'white');
}
function tree(x, y) {
  rectangle(x - 10, y - 50, 20, 50, 'chocolate');
  triangle(x, y - 50, 100, 100, 'green');
}
function house(x, y) {
  // walls
  rectangle(x - 50, y - 75, 100, 75, 'lightgrey');

  // roof
  triangle(x, y - 75, 120, 40, 'brown');

  door(x - 15, y);
}
function door(x, y) {
  // door
  rectangle(x - 12.5, y - 40, 25, 40, 'peru');

  // doorknob
  circle(x - 6, y - 20, 3, 'saddlebrown');
}

</Editor>

It's not going to win any art competitions, but that's not the point!

We made a small project with some complexity, out of simple building blocks, thanks to functions.

Conclusion

Functions are sequences of instructions, that we can label and reuse.

They are smaller programs (e.g. drawing only a house) inside our bigger program (e.g. drawing the whole painting), that help us keep our code easier to write, understand, and modify.

What we've been working with isn't a "dumbed down" version of functions. This is what it looks like in "real" code too!

Our instructions have exclusively been about drawing rectangles, circles, triangles, and other groups of them, e.g. door(x, y), but our program is by all means a real program, these are real instructions that come from a library of basic shapes.

What next?

You have now understood the concept of functions, which is the important part.

If this was new to you, I recommend you take some time to internalize the concept. Use the editor below and make your own unique painting!

// Make your own painting!

// rectangle(x, y, width, height, color);
// triangle(x, y, width, height, color);
// circle(x, y, radius, color);
// function newInstructionName(x, y) { ... }

// WARNING:
//  Your code will be lost if you refresh or close
//  this page.
//
// To save your code and the drawing
// - click on "Open Sandbox" in the bottom right
// - copy the URL
// - store it somewhere, or share it with the
//   community in the comments at the bottom
//
// Feel free to delete these grey lines

</Editor>

I'm working on new articles so you can learn about loops with the same setup, hold tight!

In the meantime, you can have a look at these (more advanced) resources:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions
https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API