414 karma · joined March 4, 2020
I make screencasts for software founders and indie-hackers. They show a behind-the-scenes tour of how I built and marketed my bootstrapped business, and they condense my decade of experience into a few hours. They are probably the only place on the internet where you'll see Vim, Google AdWords, and a database constraint in the same video.
Watch them here: https://bit.ly/328vZnO
I keep a roof over my head thanks to https://www.oxbridgenotes.co.uk/, a website specializing in selling law notes for students.
I use the Wistia player and it seems to be fully responsive on page resizes -- the issue is more that the player is constrained by the size of its column in the css. I'll put that on the list of things to sort out once I get around to hiring a designer. The css at present is an extremely rough proof of concept.
If you've got more of a taste for the slower-changing, thoroughly unsexy principles behind writing stable and maintainable software, I'm devoting myself to exploring these ideas with my screencasts - topics like data integrity, building instrumentation for knowing what's happening in your code (esp. in production), non-brittle tests, leaning on unix tools and the OS to debug things, the timeless editor vim, etc.
The first 12 videos are available over at https://www.semicolonandsons.com/ -- it's a new side-project of mine that I hope will bring some value.
I don't use any front-end framework for my JS. Instead I have a have a `main` function that gets initiated and loads up everything that I need on the page (handles, script tags, etc). I wire together interactivity with the DOM via HTML ids (I never use these for CSS, so it's clear their purpose is as JS hooks). I have a `library` file with useful functions (e.g. grabbing query params, hiding or unhiding elements.
If this all sounds very basic, it's because it is. I don't need anything more.
Even though I'd consider myself good with linux etc., I still love Heroku because it's a massive time and stress saver not to have to deal with most deployment issues myself.
Basically I've run a profitable production web app for 10 years (~14k LOC, 200k monthlies, revenue higher than any day-job I could get) as well as a few Android/IOS apps.
Now I'm creating videos where I show various real-world aspects of writing software in the context of my own production code - e.g.
- architecture
- rapid response systems to production errors
- dependency choices
- data integrity guarantees
- integration testing systems
- softer stuff, like optimizing for SEO and on-page conversion.
There's not enough non-beginner material out there and I hope to help fill that gap in resources.
They're all available here: https://www.semicolonandsons.com/series/Inside-The-Muse
Looking back, the best technical decisions were:
- using an SQL database with lots of constraints and foreign keys and indexes. It's like typing for data.
- emphasis on shell scripts and leaning on UNIX features (since these continue working in ten years rather than being abandoned)
- deleting as many libraries and dependencies as practical (over a ten-year time frame, 80% will disappear or change in ways that require huge mental RAM on your behalf)
- a preference for paying for hardware to solve performance issues (vs. complicating the code with fancy solutions)
For anyone interested, I go into more detail in this video https://www.youtube.com/watch?v=rQegYUsU7ec
To that end, I keep a mistake log, into which I insert an entry after doing something that either caused down-time or that caused my team to lose over an hour of productive time. It now has over 500 entries in story format, along with the relevant code. Some example titles (along with their tags in square brackets):
- [gotchas] references to relative file paths are brittle when there are multiple entry points to a program
- [gotchas] lazy evaluation cannot be cached in most systems
- [unix] adding `sudo` affects $PATH and can cause commands not to be found
- [gotchas] never confuse STDOUT with return value
- [collaboration] never remove a flow in code without consulting all possible stake-holders
- [algorithms] when calling a sorting function, always ask yourself if alphabetical or numerical
I plan on posting a video with more details on my YouTube channel soon.
I just started a YouTube channel where I give behind-the-scenes looks at how the technical and the business sides connect.
Specifically, I'm covering things like
- Experiments in SEO (from outsourced freelance content to microdata, to preserving SEO juice when user-generated content changes)
- Basic Google Analytics game
- The surprising hidden costs with payment providers like PayPal/Stripe
- AB testing
- The hell that is sales tax accounting
- Using data to decide what features to build (minimal viable features), so you don't over-invest limited resources in uncertain rewards.
- Technical cost-cutting (e.g. having a shitty looking admin area, knowing what not to test)
- Handling customers gracefully (e.g. setting expectations about response times, letting them yell at you and still feel zen, why you should always give refunds)
So, for a frank look at one particular programmer's/solopreneur's take on the above, you might get value from my channel: https://www.youtube.com/watch?v=aCzT-LQI6x0
As regards educational content, I'm at an early stage with this, but I've got a couple of videos over on YouTube https://www.youtube.com/channel/UC17mJJnvzAa_e9qQqLIfIeQ
As for your question as to why there are so few intermediate level learning resources, I think it's because the market size for intermediate stuff is much much smaller than it is for beginner resources and therefore content creators prefer to focus on the beginner stuff.
Much of reddit still has functioning referees in the form of its moderators, but I'm seeing signs of it cracking — e.g. when I researched the backgrounds of certain moderators I found out that they produced content in some space and would allow their own stuff to get posted while blocking other people's submissions.