humnom.net

A portfolio is a curated collection of work samples that demonstrates what you can do, rather than describing what you have done. It differs from a personal blog, which is a running record of thoughts and updates, and from a resume, which is a chronological list of roles and skills. If your goal is to prove capability to a client, employer, or collaborator, a portfolio is the right format; if your goal is to share ongoing ideas or apply for a job through a formal hiring pipeline, a blog or resume may serve that purpose better.

The core purpose of a portfolio

A portfolio answers one question: can this person actually do the work? Everything in it should support that answer.

• It shows, not tells. Instead of "skilled in JavaScript," a portfolio shows a working project.
• It is selective. A portfolio with three strong projects beats one with twenty weak ones.
• It is audience-facing. You choose what to include based on who will look at it.

This is why portfolios are common among software developers, designers, photographers, writers, and freelancers — roles where the quality of output matters more than a job title.

Portfolio vs. personal blog

These two often live on the same website, which is why they get confused. The difference is in intent and structure.

A blog can feed a portfolio — a post explaining how you built a project can link to the project itself. But a blog post is not a portfolio entry unless it demonstrates a concrete result.

Take Humnom.net, the personal site of software developer Yuri Sizov. Its description pairs "his portfolio and blog" as two distinct sections. That split is typical: the portfolio holds the work, the blog holds the writing. Keeping them separate helps a visitor who only wants to evaluate your work skip past the commentary.

Portfolio vs. resume

A resume is a summary; a portfolio is evidence. They are not substitutes.

• A resume lists. "Developed a REST API for internal tooling, 2022–2023."
• A portfolio demonstrates. A link to the API, a description of the problem, the constraints, and what changed as a result.

Use a resume when a formal process requires a standardized document — most job applications. Use a portfolio when you have room to show depth, such as a freelance pitch, a portfolio review, or the "website" field on an application.

A practical pattern: the resume states the claim, the portfolio backs it up. If a resume line says "built a game in Godot," the portfolio entry shows the game, the mechanics, and what you learned building it.

What a portfolio usually contains

Most effective portfolios include the same basic elements, regardless of field:

1. A short introduction — who you are and what kind of work you take on.
2. Project entries — each with a title, the problem or goal, your role, the process, and the outcome.
3. Visual or interactive evidence — screenshots, live demos, repositories, or published pieces.
4. Context on constraints — timeline, team size, tools, or client requirements, so the work is judged fairly.
5. Contact information — how to reach you, stated plainly.

For a developer, an entry might link to a repository and a live demo. For a designer, it might show before-and-after states. For a writer, it might include published clips with links to the original outlet.

Choosing the right format for your situation

The right combination depends on what you need the reader to do.

• Software developer applying to jobs: resume for the application, portfolio site for depth, blog optional. Link the portfolio from the resume.
• Freelancer or contractor: portfolio first, since clients evaluate output directly. A blog can build trust but is secondary.
• Designer or creative: portfolio is essential; a resume alone rarely conveys visual or craft quality.
• Someone building an audience: blog first, with a portfolio page for finished work you want to highlight.

If you are unsure, start with a single page that lists three projects with links and a short paragraph each. That is a functioning portfolio. You can add a blog later if you find you have things to write about regularly.

Common mistakes to avoid

• Treating the portfolio as an archive. Not everything belongs. Curate.
• Describing the project without showing it. A paragraph about a game is weaker than a paragraph plus a playable link or screenshots.
• Mixing blog and portfolio so thoroughly that neither is clear. Separate sections, or at least clear labels, help visitors find what they came for.
• Leaving out the outcome. State what the work achieved or what you learned, not just what you did.

A portfolio is not a diary and not a CV. It is a focused argument, made with work, that you can do the thing you say you can do.

Computer science is the study of computation itself — what can be computed, how efficiently, and with what methods. Software development is the practice of building working software, often using ideas from computer science but not limited to them. The two overlap heavily: a developer uses algorithms and data structures daily, while a computer scientist may write code to test a theory. The practical difference is the goal — computer science asks "what is possible and why," while software development asks "how do we ship this reliably for users."

What computer science actually covers

Computer science is usually organized around a few core areas:

• Algorithms and data structures — how to sort, search, store, and retrieve information efficiently.
• Theory of computation — what problems are solvable, which are tractable, and which are provably hard (automata, complexity, computability).
• Programming languages and compilers — how code is parsed, translated, and executed.
• Systems — operating systems, networks, databases, and how machines coordinate.
• Artificial intelligence and machine learning — how systems learn patterns or make decisions.
• Human-computer interaction, graphics, and software engineering — how people use software and how large systems are built and maintained.

These areas share one thing: they study general principles, not one specific product.

How it differs from software development and programming

Programming is the shared tool. A computer scientist writes code to test an idea; a developer writes code to deliver a feature. Neither is "better" — they answer different questions.

What a computer science degree usually includes

Most CS programs cover a common core:

• Intro programming (often Python, Java, or C++)
• Discrete math and logic
• Data structures and algorithms
• Computer organization and operating systems
• Databases and networks
• Theory of computation
• Electives such as AI, graphics, security, or game development

The degree emphasizes why systems work, not just how to use a framework. That's why graduates can pick up new languages and tools faster — the underlying concepts transfer.

Where computer science shows up in real work

You don't need a CS degree to build software, but CS knowledge helps in specific situations:

• Game development — pathfinding, collision detection, and rendering all rely on algorithms and math. A developer working in Godot or Unity benefits from understanding vectors, trees, and performance trade-offs.
• Web development — choosing the right data structure for a cache, or understanding Big-O, directly affects page speed at scale.
• Data and AI work — statistics, linear algebra, and optimization are core CS topics.
• Debugging hard problems — knowing how memory, concurrency, or networks behave makes root-cause analysis faster.

For example, if a search feature feels slow, a developer with CS training will immediately ask about the data structure and complexity, not just the framework.

How to start learning computer science

If you want to build a foundation without a formal degree:

1. Pick one programming language (Python or JavaScript are common starting points) and write small programs.
2. Learn data structures and algorithms — arrays, lists, maps, trees, sorting, searching. Practice on small problems.
3. Study discrete math basics — sets, logic, graphs, and proofs. This underpins most CS theory.
4. Build small projects — a to-do app, a simple game, or a script that solves a real problem.
5. Read widely — introductory textbooks, university course notes, and developer blogs (personal sites like Humnom.net often mix portfolio work with CS and gamedev notes) all help connect theory to practice.

You don't need to master everything before building. The most effective path is to alternate between learning a concept and applying it in code.

Bottom line

Computer science explains how computation works; software development uses that knowledge (and a lot of practical skill) to build things people use. If your goal is to ship products, learn development first and pick up CS concepts as you hit limits. If your goal is to understand the field deeply or work on hard problems, invest in the CS fundamentals — they'll pay off across every language and framework you touch.

A software developer designs, writes, tests, and maintains the code that makes software work. The title covers a wide range of jobs—from building websites and mobile apps to writing game engines and backend services—so the day-to-day work and required skills depend heavily on the specialization and the team. This explainer covers what the role actually involves, how it differs from related titles, the common specializations, the core skills, and the typical ways people enter the field.

Software developer vs. programmer, engineer, and coder

These terms overlap heavily and are often used interchangeably, but there are loose conventions:

In practice, a company's internal definitions matter more than the words. A "developer" at one company may do exactly what an "engineer" does at another. The distinction is most useful when reading job postings: pay attention to the listed responsibilities rather than the title.

Common specializations

• Web development — front end (what users see in the browser), back end (servers, APIs, databases), or full-stack (both).
• Mobile development — native apps for iOS or Android, or cross-platform frameworks.
• Game development — engines, gameplay systems, graphics, and tooling. The Humnom.net site, for example, lists gamedev and Godot among its topics alongside JavaScript, C#, and Java, which reflects how one developer can span web and game work.
• Backend and infrastructure — services, APIs, databases, deployment, and reliability.
• Data and machine learning — pipelines, models, and the systems that serve them.
• Embedded and systems — software that runs close to hardware, often in C or C++.

Many developers move between specializations over a career, and the underlying skills transfer more than beginners expect.

Core skills

Programming languages. You need at least one language well enough to build something real. Common starting points include JavaScript, Python, Java, and C#. The specific language matters less than understanding concepts like variables, control flow, functions, and objects.

Data structures and algorithms. Knowing when to use an array versus a hash map, and how to reason about time and memory, affects the quality of your code and shows up in most technical interviews.

Version control. Git is the standard. You should be comfortable with commits, branches, merges, and pull requests, since nearly all team work flows through them.

Testing and debugging. Writing tests, reading stack traces, and isolating the cause of a bug are daily activities, not occasional ones.

Problem solving and communication. Breaking an ambiguous request into concrete steps, and explaining trade-offs to teammates, is often what separates a productive developer from a fast typist.

What the day-to-day work looks like

A typical day mixes several activities rather than consisting of uninterrupted coding:

1. Writing and reviewing code — implementing features and reading others' changes in pull requests.
2. Debugging — reproducing reported issues, tracing them to a cause, and fixing them.
3. Code reviews — giving and receiving feedback to keep quality and consistency up.
4. Collaboration — stand-ups, planning, and discussions with designers, product managers, or other developers.
5. Maintenance — updating dependencies, improving performance, and documenting decisions.

The ratio shifts with seniority and company size. Junior developers often spend more time on well-scoped implementation; senior developers spend more time on design, review, and coordination.

Education and entry paths

There is no single required route. Common ones include:

• Computer science or related degree — provides broad foundations and is still common for large-company hiring.
• Bootcamps — intensive, short programs focused on practical web or mobile skills.
• Self-taught — using documentation, courses, and open-source projects. A public portfolio or blog, like the personal pages at Humnom.net, can serve as evidence of work when there is no formal credential.

Whichever path you take, a portfolio of working projects tends to matter more than the route itself, especially for early-career roles. Employers generally look for demonstrable ability to build, debug, and explain software.

Choosing where to start

If you are deciding how to enter or specialize, weigh these factors:

• Pick a language with a clear target. JavaScript if you want to build for the web; Python if you want a gentle start or data work; C# if you are drawn to game development with Godot or Unity.
• Build small, finished projects. A completed small app teaches more than an unfinished ambitious one.
• Match the specialization to the jobs near you. Web and backend roles are the most numerous; game and embedded roles are fewer and often more competitive.
• Treat the title loosely. Focus on the responsibilities in a posting, not whether it says developer, engineer, or programmer.

Game assets are the reusable files that make up everything you see, hear, and interact with in a game: sprites, 3D models, textures, sound effects, music, fonts, and UI elements. You can create them yourself, commission them, or download ready-made packs — and Kenney (kenney.nl) is a well-known source that offers "thousands of completely free game assets," with an all-in-one package available for downloading everything at once plus free updates. The main thing to get right before you commit is licensing: check whether a pack is public domain/CC0 (no attribution needed) or requires credit, and confirm the license covers commercial use.

The main categories of game assets

Most packs are organized by genre or style (platformer, top-down, puzzle), which matters more than raw file count — a consistent art style saves you from a mismatched-looking game.

Licensing: what you actually need to check

• CC0 / public domain — no attribution required, commercial use generally allowed. This is the simplest case.
• CC-BY — free to use, but you must credit the creator in the way they specify.
• Custom licenses — read the actual terms; some restrict commercial use, redistribution, or use in certain engines.

Kenney's assets are presented as "completely free game assets for you to use," and the site also offers a paid all-in-one package and a club membership for early access and extras. Free availability and paid convenience tiers can coexist, so treat "free to download" and "free to use commercially" as two separate questions and verify each.

Where to get free assets

Kenney is a concrete example of a CC0-style library: you can browse and download individual packs for free, or get the all-in-one package to grab everything at once with free updates. The site also publishes free and open source Starter Kits for various game genres, aimed at people new to game development, plus tools for creating 3D models without deep knowledge of complex software or frameworks.

Other common routes: itch.io asset packs, OpenGameArt, and engine marketplaces. Whatever the source, download one pack first and test it in your project before building around it.

Importing and organizing assets in Unity, Godot, and Unreal

The steps are similar across engines:

1. Create a folder structure before importing — e.g. Art/Sprites, Art/Models, Audio/SFX, Audio/Music, UI. Consistent naming (player_idle_01.png) prevents chaos later.
2. Drop files into the project (or use the engine's import menu). The engine generates its own metadata files — don't move assets outside the editor or you'll break references.
3. Set import settings per asset type: sprites need pixel-per-unit and filter mode (point filter for pixel art); 3D models need scale and material import options; audio needs compression and loop settings.
4. Verify in a test scene — place one sprite, one model, and one sound to confirm scale, pivot, and playback before importing the whole pack.

Expected result: assets appear in your project browser, drag into scenes, and render/play correctly. Common snags: wrong scale (models huge or tiny), blurry pixel art (filter mode left on bilinear), and broken references after renaming files outside the editor.

Practical checks before committing to a pack

• Style consistency — do the sprites, UI, and fonts look like they belong to the same game?
• Format fit — does your engine import the provided formats directly, or will you need conversion?
• Coverage — does the pack include the animations/states you need, or only static art?
• License clarity — is the license stated on the download page, and does it match your intended use?
• Scale test — import a few files and check them in-engine, not just in a preview image.

If you're just starting out, a single consistent free pack plus a Starter Kit is usually enough to prototype a full game loop before you invest in custom art.

Lerna is a build system for managing and publishing multiple JavaScript or TypeScript packages from a single repository. It fits teams that keep several interdependent packages together and need coordinated versioning, publishing, and task running. If you only have one package, or your packages never share code or releases, Lerna adds overhead without much benefit.

The core problem Lerna solves

A monorepo puts many packages in one repository. That makes sharing code easy, but it creates coordination work:

• Which packages changed since the last release?
• What version should each changed package get?
• In what order should packages be published so dependencies exist first?
• How do you run a build or test across all packages without doing it manually?

Lerna addresses these by understanding the dependency graph between your packages and acting on it.

How Lerna manages a monorepo

Versioning

Lerna tracks which packages changed and updates their versions together or independently. It supports two common modes:

• Fixed mode: all packages share one version number and are released together.
• Independent mode: each package gets its own version, so you can release only what changed.

The choice matters. Fixed mode is simpler and suits tightly coupled packages. Independent mode gives finer control but requires more discipline.

Publishing

When you publish, Lerna determines the correct order based on inter-package dependencies, so a package that depends on another is published after its dependency. It can also create git tags and update changelogs as part of the release.

Running tasks across packages

Lerna can run a command (build, test, lint) across multiple packages, and it can scope that to only the packages affected by recent changes. This is the part that saves the most time in large repos, because you avoid rebuilding everything on every change.

Lerna and Nx

Lerna is now part of the Nx ecosystem. The relationship matters when you choose tooling:

• Lerna handles the monorepo versioning and publishing workflow.
• Nx provides the broader task running, caching, and project graph capabilities.

In practice, Lerna can use Nx under the hood for task execution and caching. If you already use Nx, Lerna fits as the release layer. If you only need publishing and versioning, Lerna can stand alone.

Lerna vs. plain npm/yarn workspaces

Workspaces solve dependency linking. Lerna solves the release and task-orchestration layer on top. Many projects use both: workspaces for installation, Lerna for versioning and publishing.

When Lerna is the right choice

Consider Lerna when:

• You maintain multiple packages that depend on each other.
• You need repeatable, ordered releases rather than manual npm publish per package.
• You want to run builds or tests only for packages affected by a change.
• You are already in or moving toward the Nx ecosystem.

Look elsewhere when:

• You have a single package.
• Your packages are released independently by different teams with no shared release process.
• You only need local linking and never publish.

Where to start

Begin with the Lerna documentation at lerna.js.org. The typical first steps are initializing Lerna in an existing repository, defining your package locations, and choosing fixed or independent versioning before your first release. Getting the versioning mode right early avoids a painful migration later.