
Challenging projects every programmer should try - azhenley
http://web.eecs.utk.edu/~azh/blog/challengingprojects.html
======
jfoster
I think the #1 project every programmer should try is a project that has
customers. There's so much involved in achieving that. It will possibly prove
more difficult than any of these. It will probably lead to a different
understanding of every other project that programmer then takes on, too.

~~~
paxys
Solving a programming problem is very different from solving a business
problem, and building something that has customers falls more into the latter
category. Lots of people want to simply improve their programming and problem-
solving skills, and this list is perfect for that. Customers add a whole new
dimension of complexity which most people might not want to deal with,
especially with fun side projects. So setting the expectation that everything
you build needs to have customers is definitely wrong.

Building stuff like a text editor, simple game, database etc. from scratch
which will never be used by anyone other than yourself can be immensely
challenging and satisfying.

~~~
tarsinge
I discovered over the years that I like solving business problems, but in that
context programming is purely utilitarian and just a tool like I would use in
another industry. But since I also love coding, I code in my free time without
any constraint other than having fun and improving.

So for me the solution was simply moving away from an every day developer job
at work and more into a product management/CTO like role.

~~~
random_kris
How did you start making a change? I feel like I'm in the same boat

~~~
tarsinge
What worked for me was transitioning to a “solution engineer” role. The name
can vary but basically it’s consulting and integration to help clients use the
product. Here I got an overview of the whole lifecycle of a product from a
client perspective: their business problem, the need for a solution, the
product fit and the sales process, then the integration challenges, user
training, and hopefully a good reference and testimonial for securing the
renewal and providing the marketing with material. There was always a
“tension” between what the client wanted and what the product was doing, but
learning how to understand their need and the appropriate answer (technical or
not), and when does it really make sense to add a feature to a product was the
key skill I learned to develop in that role. Participating in sales meetings
was invaluable for starting a business later but maybe less relevant strictly
for product management.

------
userbinator
_The biggest challenge is figuring out how to store the text document in
memory. My first thought was to use an array, but that has horrible
performance if the user inserts text anywhere other than the end of the
document._

The counter-argument to that is that processors are ridiculously fast in human
timescales --- copying memory at gigabytes per second --- so unless you're
focusing your use-case on editing correspondingly huge files, there's no real
need to make your implementation more complicated than a single array. Even
when DOS machines with <640K of memory and memcpy() speeds in the low MB/s
were the norm, people edited text files of similar sizes, with editors that
used a single array buffer, and for that purpose they weren't noticeably
slower than ones today.

My ideas for challenging projects are a little less open-ended, so they
exercise different set of skills: being able to implement a specification
correctly and efficiently.

    
    
        - TTF renderer
        - GIF or JPEG en/decoder
        - Video decoder (start with H.261)
    

IMHO being able to consume existing content with code you wrote is very
rewarding.

~~~
retrovm
"no real need to make your implementation more complicated than a single
array"

That's our industry in a nutshell. Our computers, instead of becoming more
capable over time, can barely keep pace with the increasing naivety of our
programmers.

~~~
OkGoDoIt
Are you suggesting that it’s bad to use the simple uncomplicated approach
because it’s inefficient, or that it’s bad to add layers upon layers of
complexity which end up bringing modern computers to their knees?

Personally I’m in the latter camp. There’s so many layers of abstraction
nowadays which each in theory make programming better/safer/easier which in
practice end up creating an incredibly inefficient mess.

~~~
srtjstjsj
Vim is 25 years old. Efficient text-handling data structures aren't newfangled
gobbledygook.

~~~
anthk
And vi is even older. Plus ed...look at the release date.

------
wool_gather
Kind of related, there's this list of "Build Your Own $FOO" (that I'm pretty
sure I learned about here on HN originally :)
[https://github.com/danistefanovic/build-your-
own-x](https://github.com/danistefanovic/build-your-own-x)

\- Build Your Own Text Editor

\- Build Your Own Shell

\- Build Your Own Git (!)

etc.

Comes complete with the Feynman quote "What I cannot create, I do not
understand".

~~~
winrid
Wasn't the quote, what I cannot explain I do not understand?

~~~
wool_gather
Hah, yes, good point, I think you're correct about that.

The repo has an _adaptation_ of the quote, then. :)

------
cletus
Honestly, I hate the way these articles are framed: "X things every programmer
should [read|try|learn]". I've certainly seen a list of 1000 books everyone
should read. I hate the way these are framed because you'd spend your entire
life doing all of them so it's clearly not practical.

Can we step away from the hyperbole here and just start saying (in this case)
"Interesting project ideas" or somesuch?

This of course leads to people piping up their own "must dos" like "write a
compiler" (huge undertaking).

Interestingly I see a comment here like "do something with actual customers"
and the replies are interesting, essentially dismissing this as a business
rather than technical problem.

I find this interesting because software exists to solve problems for people
so this is probably the most useful advice I've seen. The ability to identify
a pain point and use software to solve it is arguably the most useful ability
a software engineer can have.

You will of course learn things by writing a compiler or . text editor or a
ray tracer and if scratches an itch for you, by all means go for it.

~~~
calcifer
The author thinks these are valuable challenges every programmer _should_ try.
Not must, _should_. It's just an opinion. If you don't agree with it, then
don't do the challenges. Why does it cause you to write a 200 word rant?

~~~
AnimalMuppet
Why did cletus' post cause you to write a 40 word rant?

I thought it was a valid point. 1000 books I should read? If I devoted all my
free time, for the rest of my life, I might make it. But that leaves me
exactly zero time left for the next person who's got some fine-sounding
"should" for me, or the next, or the one after that. It's _all my time for the
rest of my life_ \- for _one_ person's "should".

I don't think it changes the problem to say "should" instead of "must". It's
just an opinion. It doesn't create any more of a "should" for me than it does
of a "must".

------
lancefisher
These are great suggestions!

A few years ago I worked through building a spreadsheet in JavaScript. It was
a great introduction to interpreters. I read through Writing an Interpreter in
Go by Thorsten Ball [1]. Constraining the interpreter to execute formulas in
cells was a straight-forward way to approach building one from scratch.

Writing a Pratt parser as part of this forced me to understand how it works.
Figuring out how to process a sheet led me into algorithms and structures like
directed acyclic graphs (as mentioned in the article). I found myself
referencing Introduction to Algorithms and really studying it [2].

In the end I turned it into a talk at Big Sky Dev Con in Montana. The whole
thing was a good experience - from researching how to do it, to sticking it
out through the implementation, to distilling it to a 45 minute talk. Be sure
to check out the recording [3] and code [4] if you're interested.

Any of these suggestions will lead you down a rabbit hole of learning with a
clear objective in sight to keep you motivated to dig deeper.

[1] [https://interpreterbook.com/](https://interpreterbook.com/)

[2] [https://www.amazon.com/Introduction-Algorithms-3rd-MIT-
Press...](https://www.amazon.com/Introduction-Algorithms-3rd-MIT-
Press/dp/0262033844)

[3]
[https://www.youtube.com/watch?v=Sj4h0DcVLL0](https://www.youtube.com/watch?v=Sj4h0DcVLL0)

[4]
[https://github.com/lancefisher/cellularjs](https://github.com/lancefisher/cellularjs)

~~~
will_pseudonym
Thank you for sharing this, Lance! I'm a "recovering actuary/Excel power
user/Excel developer (shudder)" currently in Lambda School in their web
development track.

I'm really enjoying watching the recording of your talk, and in addition to
learning one way to build a spreadsheet, I'm also learning lots of good
software development practices orthogonal to the specific project, which is
great.

Again, thank you for sharing!

~~~
lancefisher
Thanks! Glad you like it!

~~~
will_pseudonym
By the way, I'm curious, how did the company you work(ed?) for in Missoula,
MT, get started? I'm always interested when I come across software companies
in non-megalopolises.

~~~
lancefisher
The three founders live here, and wanted to build a software company. They
worked hard to make something people wanted, and raised money from the three
Fs (friends, family, and fools). They applied to YC on a lark, actually got
in, moved to Mountain View for 3 months, learned a ton and made good
connections.

After gaining traction in the market it was possible to raise from angels and
then VCs.

I believe you can build and sell software from anywhere if you have the drive
and find a way to solve problems that people are willing to pay money to
solve.

Here's an article that talks more about it:
[https://missoulacurrent.com/business/2018/08/missoula-
tech-s...](https://missoulacurrent.com/business/2018/08/missoula-tech-
submittable/)

------
barrkel
Write a database. Depending on what angle you take, it can look like a
compiler (SQL parsing, predicate evaluation, optimizing for index usage), OS
(file systems for in-place updates of complex data structures, and scheduling
with lock dependencies), distributed systems (consistency and availability
tradeoffs across machines, with possible partitions).

And then there's the whole mental model of relational algebra and stream
processing of queries.

It'll give new appreciation for existing databases and what they can and can't
do for you.

~~~
Transfinity
One of my favorite courses in college was basically this. I learned so much
about filesystems, data structures and concurrency that has been useful in my
career!

------
artfulhippo
For me, it's hard to learn by making useless things. Without any impact for
users, I have no motivation to make correct design decisions.

~~~
annnoo
It differs from person to person I guess. For me it is more about learning and
understanding stuff. It motivates me more than doing my day to day job,
because I encounter completely different domains and problems :)

------
gmenegatti
IMHO I think databases could be added to the list.

It’s one of the most complex system one can develop and you end up learning
about multiple areas, such as OS, compilers, distributed systems, data
structures, parallelism etc.

~~~
krn
> It’s one of the most complex system one can develop

The same could probably be said about the internal combustion engine, but it
might soon be replaced by electric batteries, which provide a much more
elegant solution.

I believe that "unbundled" databases, such as Crux[1], can become the electric
batteries of the database world by making a lot of the current complexity
irrelevant.

[1] [https://opencrux.com/](https://opencrux.com/)

~~~
detaro
What makes crux's internals less complicated than a more conventional
database?

~~~
refset
1) the single-writer principle of the transaction log means there's no need
for any transactional locking

2) the separation of reads and writes allows for elegant horizontal read-
scaling without coordination/consensus

3) pluggable storage backends implemented as simple Clojure protocols (as the
sibling comment mentions), which eliminates a large number of performance and
durability concerns

4) combining schema-on-read with entity-attribute-value indexing means there's
no need to interpret and support a user-defined schema

5) Datalog is simpler to implement and use than the full SQL standard or
alternative graph query languages

...I work on Crux :)

~~~
simplify
Please tell us more about point 5!

~~~
refset
Crux uses a Worst-Case Optimal Join [0] algorithm with bitemporal indexes, and
the Datalog-specific query layer is implemented in less than a thousand lines
of Clojure: [https://github.com/juxt/crux/blob/master/crux-
core/src/crux/...](https://github.com/juxt/crux/blob/master/crux-
core/src/crux/query.clj)

SQL certainly provides a lot of bells and whistles but Crux has the advantage
of consistent in-process queries (i.e. the "database as a value") which means
you can combine custom code with multiple queries efficiently to achieve a
much larger range of possibilities, such as graph algorithms like
Bidirectional BFS [1].

[0]
[https://arxiv.org/pdf/1803.09930.pdf](https://arxiv.org/pdf/1803.09930.pdf)

[1]
[https://github.com/juxt/crux/blob/master/docs/example/imdb/s...](https://github.com/juxt/crux/blob/master/docs/example/imdb/src/imdb/main.clj)

------
TheOtherHobbes
This is a surprisingly nostalgic list. It's not that there's no benefit to
these projects, it's that there are more modern projects - custom web servers,
practical DSLs, 2D and 3D iOS/Android games, simple AR, simple ML, simple
embedded hardware - at a similar level of difficulty, which are easier to
extend to real commercial applications, and also teach important CS
fundamentals.

You could also do worse than learn Erlang, Haskell, Julia, or some other
interesting-but-not-really-mainstream language.

I'm surprised the author appears to be a millennial. I would have expected a
list like this from someone my age, who started coding when TinyBASIC and
Space Invaders were the new shiny.

~~~
Footpost

       practical DSLs
    

Isn't embedding a "practical DSLs" another toy compiler?

Except that with a DSL, you have to worry about gnarly but not-so-interesting
problems like what happens to my syntax (given by a CFG) when I add another
syntax (another CFG)? Are the combined CFGs ambiguous etc?

Keep things simple!

------
petethepig
A few things I did in the past I would definitely recommend:

* Make a Lisp [https://github.com/kanaka/mal](https://github.com/kanaka/mal) — tutorial on how to make a lisp language interpreter.

* Make an 8 bit computer [https://eater.net/8bit](https://eater.net/8bit) — tutorial on making a simple 8 bit computer out of a bunch of AND, OR, NAND chips. Really helps you understand how computers work, what microcode is, etc. Honestly, building it wasn't quite as much fun as I thought it would be, but just learning how to build one was very useful.

~~~
macintux
When I tried MaL I got hung up on the regex in one of the first steps, which
is complex and tricky to translate into any of the umpteen other variants of
regular expressions, and utterly vital to the overall project. Frustrating.

------
chooseaname
I would like to add that a good project is to fix some bugs or add some
feature to a project like, say, GNU Octave; especially for new developers. It
really expands your mind as a new developer learning how to _read_ code and
understand where to make changes and add features.

~~~
azhenley
I agree! I'll be teaching a graduate-level SE course in the future and I
intend on making contributions to open source projects a requirement.

~~~
closeparen
I sat around with a desire to “make an open source contribution” for _years_.
Followed the advice about looking through bug trackers for tractable issues.
Never could make heads or tails of a project.

Then at work I become an ambitious user of a relatively immature open source
platform. As a power user, I finally had real motivation to fix specific
defects, and a good enough mental map to get it done. It came naturally.

------
tus88
> First, you'll have to learn to draw to the screen. I had no idea how this
> worked. You are actually clearing the screen then drawing each portion of
> the screen in rapid succession, many times a second, to create the effect
> that objects are moving.

Not if you're double buffering you aint.

~~~
tydok
We use double buffering to avoid flickering, but still we have to clear the
back buffers.

------
lmilcin
* Low latency. Receive at 10k messages per second (one every 100 microseconds), have non-trivial amount of business logic, ensure all responses are sent within 50 microseconds. I did a proof of concept of algorithmic trading platform in C/Common Lisp for a brokerage house that was interfacing stock exchange, was tested to withstand 10k mps over an hour with 10 microseconds end-to-end latency (measured on switch). I learned A LOT.

* Non-trivial application with very restricted amount of memory, crappy networking, that has to be very reliable. I did an entire payment POS application (EMV, contactless) on a very ancient device. It had total of 2MB of memory (SRAM + flash, it had execute in place). I needed to do a lot of research to optimize the application for memory usage -- for example, had to implement transactional database to work within constant amount of memory. I also needed to research a lot of techniques to make my application reliable regardless of what happened. I also learned A LOT on that project.

~~~
saberience
In typical HN fashion, this just sounds like an excuse to jaw about your
resume projects.

How would these clearly niche projects be something "every programmer" should
try? When in enterprise engineering is 2MB a normal amount of memory for
something to need? I'ved worked in videogames, fintech, e-commerce and worked
on many kinds of systems and not run into anything with such requirements.

Not to mention, the sorts of "lessons learned" on such projects could actually
hurt an engineer when working on more realistic enterprise systems. At my
current job (where I manage many teams of engineers), if I saw engineers
micro-optimizing to save 2 MB of memory instead of getting features shipped I
would ask their tech-lead wtf was going on.

I've seen far more damage done by premature optimization in my career than
I've seen it actually help matters. Engineers trying to be "extra smart" and
show of their extreme memory/cpu optimization skills so often leads to wasted
time, hard to debug code, or worse, annoying bugs which are much more
difficult to diagnose later.

~~~
lmilcin
You miss the whole point of the list. The idea is that experience of working
on variety of projects makes you better developer in whatever field you are
in.

This assumes you will understand where to use and when not to use those
techniques.

The list gives examples of projects each with unique requirements. Each
requiring you to think about the problem in a different way.

I just gave two more examples that I personally found very illuminating, that
also have unique requirements, different from other projects on the list.

I may be working on some more mundane software atm but, for example, I know
how specifying size of every buffer or any data structure is important for
reliability of the service I am working on.

In fact, the service had bad track record of reliability which was quickly
fixed by specifying what it means to do stream processing (no unbound data
structures in memory, etc.) and quickly verifying each component against this
spec.

I learned this and many others from MISRA which is standard to help write
reliable software for automotive industry. I adopted it for my embedded app to
help me work on complex app that had to be very reliable.

------
skizm
A lot of these things involve graphics. Every time I try doing my own graphics
(not using an engine like unreal/unity) I have trouble even getting a triangle
to show up on screen. There is nearly always _something_ that doesn’t work
like the tutorial says it should and that isn’t common enough to come up when
I google the error. In C/c++ I can never get the toolchain working correctly
and compiling step one never works even when I pull the authors project
exactly. Last time I tried pygame it turns out it like just doesn’t work on
Macs or something? None of the examples worked, just got blank boxes. Couldn’t
make it past the first few steps in lazyfoo’s tutorial, even unreal engine’s
tutorials are constantly being outdated due to short release cycles, although
I’ve had the most success with unreal.

I’m not sure if I’m just thick or something, but any project that involves
low-ish level graphics I shy away from because I’ve had so much trouble in the
past.

~~~
pjc50
It might be genuinely easier to do it in emulated MSDOS QBASIC or BBC BASIC.

~~~
progman32
Check out QB64. Modern implementation of quickbasic. Looks, behaves, and feels
like the original if you want it to.

------
bogdanoff_2
>how do you generate a dynamic number of enemies? The factory pattern helps a
lot.

Why?

The factory pattern is about adding logic and state to the creation of
objects. What's wrong with creating enemies using their usual constructors and
dumping them into a resizable array?

~~~
jayd16
You use a factory when you have code that needs to create something but
shouldn't determine the details of their creation. If you want to create
enemies from multiple places (seems common) you don't want to have to refactor
every place when you change something about the creation or pooling.

~~~
bogdanoff_2
Yes, if you determine that creating your objects requires passing in state or
using some logic that you don't want to put in the constructor, then using a
factory or factory function makes sense. However that has nothing to do with
creating a dynamic number of enemies.

Object pooling is a good point actually.

------
azhenley
If anyone has any other good ideas, please let me know. I'll make a list of
them at the end of the article and provide credit.

~~~
wefarrell
MS paint clone.

~~~
chupa-chups
You'll have to establish an MVP program on top of the clone:

[https://weblogs.asp.net/alex_papadimoulis/430478](https://weblogs.asp.net/alex_papadimoulis/430478)

</fun>

------
aklemm
Perhaps something web-based--perhaps collaborative or real-time--and get
exposure to sessions, database work, networking, APIs, and the tooling
ecosystem, etc.

~~~
merolish
Seconded, a minimal full-stack system like a messaging service could go in
many directions depending on your interests.

------
anonytrary
I am curious why the author suggests programming spreadsheets is "hard" but
programming an operating system isn't. Arguably, all you're doing in a
spreadsheet is building a dependency graph of nodes, then re-rendering them
when an input changes. It's about as complex as building your own React.

~~~
ncmncm
Didn't somebody win an IOCCC contest with a spreadsheet coded in under 2K
bytes?

------
boothby
What a great list! Adding some suggestions... some I've done, others are goals
(especially APL and Prolog)

1\. Design a new programming language. Prove it Turing complete (or go back to
the design phase). Maybe do a compiler for it.

2\. Design some hardware. There's cheap FPGAs and nice walkthroughs for
architectures like the 6502, but my next project will probably be a custom
architecture because I've never done a proper compiler before.

3\. Raytracers! I did one in JavaScript back in '02... ah, how languages
evolve...

4\. Break your language paradigms! Learn Lisp, APL, Prolog, Haskell... This is
a meta-challenge: do another challenging project in an unfamiliar language,
and get to know powerful idioms in the language and how they're handled behind
the scenes.

------
ChrisMarshallNY
These aren't bad. They are, by no means, a definitive list. If you can do all
of these, good stuff; but there's plenty more where they came from.

To be honest, the very first professional project I ever did (in 1987), was a
complete embedded OS.

In 1983, I wrote a Space Invaders game on my VIC-20, in Machine Code. In those
days, you had to use characters to represent aliens, so I made up my own font.

I've done a number of text editors over the last 30-some years. Nowadays, most
operating system frameworks have 99% of a full-featured text editor built in,
and you can do it with a few calls to system resources.

I haven't written any real compilers (haven't ever felt the need), but I have
done a ton of parsers and whatnot.

~~~
amerine
What are you referring to when you say “operating system frameworks”?

~~~
ChrisMarshallNY
UIKit, AppKit, Windows SDK, Cocoa, Android SDK, ChromeOS, etc.

In AppKit, you can do a pretty full-featured text editor as a "Hello World"
project.

~~~
saagarjha
Which is pretty much exactly what TextEdit is:
[https://developer.apple.com/library/archive/samplecode/TextE...](https://developer.apple.com/library/archive/samplecode/TextEdit/Introduction/Intro.html)

------
ldng
How about contibuting to someone else hard project ? Because doing it alone,
whatever the level of a task, is often easier than grasping existing code base
and work with others ;-)

------
jheenan1
I think the best project to try is the one that you have little to no knoludge
of. I find sometimes the best way to learn is by failing. For myself; i hate
the feeling, and failing isnt somthing that I do well. Pushing through
setbacks strengthens your abilities and produces a new confidence that
anything is possible. Also you can bring in an outside perspective to a
project that isnt typical to that field or group. When the project is
complete; you look back and realize how far you have traveled! At that point
the wealth of knoledge can be quantitatively measured. When we streach beoyond
what seems possible, dig in a little deeper, and strive to become a little
better than we are; at that point we grasp the intangible, at that point we
define ourselves. Its thoes small victories that give birth to new
innovation,define generations,and forges a way for everythings' future. If you
stand up and tackel the unknow, brush off the ridicule of ignorance,and get
crazy enough to defy logic itself; I belive thoes minuscule moments in the
history of humanity are the very iota's that allowed God to see the future of
man and understand his creation is 'good.'

------
nnain
I understand this is posted on a University website, so I guess it is ok, but
gosh I've wasted way too many days of my early career chasing things that the
'seniors' said I 'should' do as a programmer.

This is just not true, but worse still it confuses people who are just
starting. You can be an exceptional front end developer with HTML/CSS/JS
scripts and not necessarily have a mini OS in your past projects.

~~~
choeger
There is a difference between "must" and "should". Take this list as an advise
on how to become better at understanding the fundamentals. A front end
developer for instance could take html,js, and the DOM as gospel. Or they
could try to understand their foundation and how the same concepts apply in
different domains (e.g., what and why are the distinctive
advantages/shortcomings of js). I prefer the latter and I think it makes me
better at my job.

Also it is kind of sad when a fellow developer is stuck with a problem that
can easily be debugged with some OS knowledge.

------
johan_larson
I can't help but notice that this post is just below PG's "Having Kids" post.
That's a challenging project right there.

------
thrower123
Either a raytracer or a software rasterizer. Or both.

~~~
azhenley
I almost added raytracer! I'll add it to the end with some other community
suggested projects. Thanks for the suggestion.

~~~
Lerc
Raytracer was the thing that sprang to mind for me.

Currently the only two I have left to do on the list are the Basic compiler
and the spreadsheet. I plan to do the compiler quite soon, once the emulator
IDE is nice enough. If I decide to do a Basic without line numbers I'll
probably be doing another text editor as well.

Not sure if I could bring myself to write a spreadsheet. I feel queasy just
looking at them.

------
jsmolka
Writing an emulator is a great project indeed. I've been working on my GBA
emulator for almost a year now and I learned so many different things about
hardware, assembly programming and video output.

------
macintux
[https://adventofcode.com](https://adventofcode.com) should probably be on the
list. You end up doing bits of several of the suggestions along the way.

------
randcraw
My suggestion: build a basic calculator then extend it... Add scientific and
fixed formats. Add functions like log, sine, exp - especially if you create
the math ops from scratch. Detect roundoff error and suppress it gracefully.
Add binary, octal, and hex base numbers and binary, shift, rotate and bitwise
operations. Add 2D graphs and 3D surfaces. Add control of illumination and
stacking order for multiple plots. Add animation. Evaluate expressions. Add
programmability.

Or just invent your own private Emacs.

------
zoomablemind
If the 'every programmer' already has a paying job, then there're may be other
ways to advance their craft. For example, joining an open-source project
that's worth their while and maybe contribute when ready.

Of course, one's motivations may be as diverse as their perceived rewards.
Still, solving problems which need a solution always has a room for
programming/design challenges, while working with others lets one connect and
learn from the collective knowledge.

Eager minds with free time are precious!

------
aurelianito
Another interesting project is to do your own web framework. Routing, ORM,
validations that work both server and client side, rendering server and client
side transparently are some of the challenges. Just do something and improve
some actual pain point you see with a popular one. I did mine and, even thou I
have never used it for anything important, I still think it is a good learning
experience and I can point to some aspects of it that are better than all the
major web frameworks.

------
doggydogs94
I did a text editor once; it was bad.

------
cosmodisk
For those who want a real challenge I'd recommend trying to write a code that
could read/write PDF files without using any purpose built libraries.

------
thallukrish
I guess most of the time we do not know what we want to do. That's the time
you can productively spend working on improving your skills. But unfortunately
it is too hard to work on something that does not lead to worthiness of some
sort. So I guess it is good to look for something worthy to be done in their
life while sharpening your skills.

------
carapace
Implement Forth, Lisp, and Prolog. (For extra fun write your Lisp in Forth and
then your Prolog in Lisp...)

------
yoda97
Here's a good list of project based tutorials that you should follow
[https://github.com/tuvtran/project-based-
learning/](https://github.com/tuvtran/project-based-learning/)

------
bovermyer
That list sounds great, and I can see how each of those projects presents a
unique set of problems to solve.

For me, though, working on my day job and my "for fun" side project take
enough of my time and brainpower. I never lack for problems to solve.

------
rb808
Does anyone have a good guide like this but with good answers?

I can come up with decent solutions to problems, but the best way to learn is
to be able to see alternatives you hadn't thought of so you learn something
new.

------
known
[http://rosettacode.org/wiki/Rosetta_Code](http://rosettacode.org/wiki/Rosetta_Code)
is also good

------
jenscow
I was surprised to discover that interpreting BASIC to be more difficult than
a C-like language, as most statements required their own syntax rule.

------
jonasft
My "problem" is that I struggle to find the motivation to program side-
projects, when I already spend 8hours a day programming at work

------
Madmallard
You could try an realtime online multiplayer game if you want a category of
difficulty past the emulator. Lol

------
mac_was
Great idea for projects!

------
kresten
Web developers should write a simple web server.

------
prophesi
Just a quick nitpick; could the link be updated to use https? I'm a bit
surprised it doesn't automatically redirect in the first place.

------
bochoh
I'd probably do a doubly linked list for the test document. Then you're
looking at O(1) for operations I think.

~~~
zabzonk
Not for searching. Linked lists are fine if you are at the point where you
need to do an operation, but getting to that point can be expensive.

------
deepnotderp
A neural network from scratch?

~~~
cameronfraser
I thought about saying this as well, but this isn't really a challenging
programming assignment. It's a challenging math assignment, but once you know
the math the programming is very easy (assuming using a numerical library that
supports vectorization)

~~~
deepnotderp
That's fair, and you're right about that. I'd still highly recommend anyone
interested in ML to implement their favorite algorithms from scratch.

------
mrobot
software 3d renderer!

------
edisonjoao
love this

------
ronilan
If you ever wondered how the tech interview process got to where it is, here
is live example (of one possible explanation) - look at the comments,
gleefully adding more and more stuff.

So.

1\. “Every programmer” is a matter of speaking. Obviously not every programer
should try any of. Author I believe knows that.

2\. If you are not a programmer you don’t add to the list. Period. You
wouldn’t be adding to the list of “drills any dentist should try”, right? So
why here?

3\. If you are a programmer, and have not tried all of the above why are you
adding more? Yah, I know, you once did a challenging project that is not on
the list. So did I. “Doesn’t make me Madonna, never will”.

Now what if you are a programmer and you’ve done all on the list, with or
without substitution (like Snake might be equal Space Invaders)?

In which case you’d have at least 6 repos to share with the world, and if you
can implement Tic-tac-toe live, you might get to the next round of interviews.

~~~
johnfn
I don’t understand where all this negativity comes from. The OP is just
sharing some projects they found particularly fun. It’d be like a hiker saying
“every hiker should climb the Stanford dish”. Nothing wrong with that, they’d
just be sharing something that they found particularly gratifying.

~~~
detaro
People dislike the _every X should_ framing, because it's also often used in a
negative way ("you're not a real X if you haven't", "you should invest lots of
time to do these extra things", ...).

If it's "a list of projects that were particularly fun" that would be great
title.

------
chobeat
Have you considered that suggesting people to make copies of copies of copies
for the sake of a technical challenge instead of tackling real world problems
(even as beginners) might fuel the endless waste of energy that programmers
collectively pour into developing useless stuff for their own amusement? In a
world where pro-bono software development is very scarce, is this what we want
to teach to beginners?

~~~
esotericn
> the endless waste of energy that programmers collectively pour into
> developing useless stuff for their own amusement

I don't know about you, but that's pretty close to my definition of life
itself.

You are a waste. I am a waste. Do what you find fun, whilst causing the least
pain to others in the process. These look like fun projects to me.

------
master_yoda_1
Most of the undergrads do these projects if they do computer science Text
editor 2D game - Space Invaders Compiler - Tiny BASIC Mini operating system

So the author must be talking about non programmers

~~~
azhenley
Do you have evidence for that?

I asked students in my undergrad course if they had tried these. The only one
they had was the operating system. I took two different operating system
courses when I was a student and never actually implemented one.

~~~
master_yoda_1
that is the problem. your undergrad program is not challenging enough. you
should repeat your undergrad.

------
CuriouslyC
Meh. Doing a throwaway project just for the challenge of it is a horrible
waste of time. Do something useful, if you choose your project wisely you'll
learn just as much about coding, while simultaneously making the world a
better place and filling out your portfolio/resume.

~~~
artiste
If you just feel the urge to learn things and improve your skills then that
doesn't always require the project to have some practical utility. The person
who will learn the most is the one who simply does both useful projects and
projects for their own sake. Obviously with only so much time it makes sense
to prioritize the useful projects, but just speaking generally here.

------
AdrianB1
The list is fine, the title is misleading: these are not projects every
programmer should try, only the ones that want a more serious challenge than
their usual. For many programmers these challenges are too difficult and a
complete waste of time, as a certain psychologist was saying IQ is something
you cannot train and IQ is generally telling how fast you can learn new
things; with an IQ that is not enough, that time goes to infinite. Programming
is now accessible to so many people and programmers are so diverse, enough
have an IQ low enough to contradict the title.

