I suppose it's going to be a bit ironic that I'm kinda announcing my own project to the world here, which isn't as cozy and low stakes I meant this thread to be, but ahem. Feel free to crib my format (introduction, project now, its future, conclusion) if you want to, it helped to make this comment better.

My project

I'm creating an app to generate random notes, chords and scales for musical practice. The closest thing I've found is Bret Pimintel's random note web app, which I recommend you to try out right this second. I'm also using the occasion as an excuse to learn Haskell.

To those not in the know, things that sound exactly the same on when played on the piano may not be the same always. Piano tuning is a compromise and thus augmented seconds and minor thirds sound exactly the same. But when sung, they sound distinct. Theory reflects this too, which matters when you need to name and notate notes. I did some research on how others deal with these issues in web apps and dare I say: badly or hardly not at all. Bret Pimentel has the nicest system, but I'm not sure whether it's extensible beyond it's original purpose. This is where my project comes in.

Where's my project currently

Modelling music theory is essentially complete, but the app lives on the command line without a graphical UI. There are also no options to make drills nor does it care about user input. If I run the program in terminal, it will generate ten random minor or major keys

[g,d,b,B♭,b♭,f♯,d♯,G♭,G♭,g]

where lowercase letter are minor keys, uppercase ones a major keys. It's not obvious from the output, but the program can handle arbitrarily many accidentals with ease, like C𝄪𝄪𝄪𝄪𝄪𝄪𝄪♯, which in a silly way has 15 sharps and corresponds to the C♯/D♭ key on the piano. It's a side-effect of having a principled system. I don't need to deal with special cases, so even ludicrously unlikely cases get treated correctly.

For the nerds in audience, think of it as arbitrary precision integer arithmetic vs using ints. I don't trust ints and dealing with special cases here. Performance doesn't matter, thus the high road is the easiest road.

Where's my project going

The next step is learning to create a web app using Haskell. I've never created a web app before and I'm not exactly sure which way I should go. Ideally something that lives 100% in the browser would be neat, I don't want to create a service that handles user data and log ins and shit. It would be nice updating could be just as easy as uploading some compiled html file and letting users refresh the site.

Conclusion

Somewhere in February I'll publish a pastiche of Pimentel's app. It should be the most principled web app of its kind available, even if not overly ambitious otherwise. Because of its principled modelling of music theory, it should be easy to extend so it could be more than that and I don't have to fight ad hoc logic to implement it. It will probably look like ass at first as I'm not a web designer.

I'm a bit skeptical myself whether it's really worth it. It's roughly double the effort, but for what gain? For something tutorial like or educational I can see the benefits (well-managed group work is usually beneficial), but the way pair programming discussed is, like, always evidence free, seemingly reflecting aesthetic preference or social style more than anything. Which is not to poopoo either of those completely, it's just rather a beginning than a conclusion.

if u made a game about golf you'd be par programming

yeah that makes sense! it's great for sharing knowledge at the beginning, and we've been doing it a lot cause we're doing a new project this month. once the amount of new stuff getting added slows down then i hope we can go back to regular work.

I think pair programming can be great, but the secret is that it has to work for everyone who wants to do it. I like to work by myself sometimes so I wouldn't want to do pair programming everyday, but sometimes it is helpful especially when getting a project off the ground. When two developers are working together like that, you can branch away by establishing clear areas of ownership and then popping off and working on those areas separately, then consulting again when it is time to merge them together.

Next level:

if (memcmp(0x00001000, 0x00002000, 256) == 0) {
...
}

yeah this sounds like good advice. i kinda wish i had gone that route with this project and just handled type coercion and pagination myself

I feel that ORMs can be useful in certain projects, especially ones where you are building a small app to interact with an existing database and want to get off the ground running fast. If you end up interacting with a dataset that is very relational, you'll start running into some of the edge cases of optimization in ORMs and end up with N+1 queries and such.

I have experience with Hibernate in Java and SQLAlchemy in Python. In general I like them both but I tend to avoid them for projects where the DB schema is simple and just roll my own DAO layer.

now wrap it all in a BooleanTestingNullGeneratorFactoryFactory and its ready

no