Hacker Newsnew | past | comments | ask | show | jobs | submitlogin
Ask HN: What programming tutorial/course/article/blog would you like to see?
53 points by bartq on Dec 12, 2021 | hide | past | favorite | 92 comments
For many months if not years I've been thinking about sharing knowledge I have. That's natural order of things of course, but because of limited opportunities of face to face contacts I didn't really have a chance to listen to people's problems and challenges. I work as full time software engineer, but also I do a lot of experiments and side projects. Because of that I've accumulated lots of different impressions and perspectives.

So I'm asking here: what would you like to read about, what are your current doubts about programming in general or related to dreaded by many subject of JavaScript and frontend frameworks. Is there any 'next level' you'd like to reach?

This question can help many other people in situation similar to mine. Thanks!



I would be glad to find an integrated guide on how to build a state-of-the-art website and how to deploy/maintain it on a server like AWS or DigitalOcean.

I mean, I'm not interested in a html/css/javascript tutorial, we have enough resources on that. What I found really missing on the internet (maybe I'm not that good at searching), is a step-by-step detailed guide on how to deploy/update/maintain a website. An unordered list of thing that came up to my mind:

- How to deploy the website on a server

- Which server should one use

- How to expose it on the internet (buy domain name)

- Version control and hosting the repository (GitHub vs gitlab vs ...)

- Updating your website (CI/CD like Jenkins?)

- Reproducible environments (Docker?)

- How to integrate analytics

- How to integrate ads respectfully (of your users)

- How to integrate paying contents

- How to address security

- Ho to address scalability


Unfortunately much of the answers, and in fact your questions are transient, they will become outdated fairly quickly - or are not necessary even now for arbitrary "websites". The tooling for web development has become overly complex and we are now starting the trend back down to the basics instigated by projects such as esbuild.

If you aren't familiar with any of this stuff, i'd recommend focusing on the fundamentals (HTML, CSS, JS), avoiding CI/CD at all cost, avoiding complex back-ends that require fragile docker containers to ever work. Get familiar with the basics of running a simple static web server and simply upload your files via rsync. Then start approaching dynamic backend runtimes, php, nodejs (with caution). The reason I recommend this approach is that much of the complex tooling and environments you will no doubt encounter in tutorials is extremely opaque, they can provide you a giant leg up to get up and running with something impressive, but will give you very little insight into how or why.

From this point on everything gets opinionated and project specific... which is why it's hard to write a timeless and comprehensive guide.


> they will become outdated fairly quickly - or are not necessary even now for arbitrary "websites". The tooling for web development has become overly complex and we are now starting the trend back down to the basics instigated by projects such as esbuild.

To add to my other comment in this thread, as this relates to your particular comment, we try to keep Molecule.dev as up to date as possible. We cannot of course cover every piece of tech out there, but we attempt to cover what we think are the best tools available and will continue to exist and improve for many years to come.

It is definitely a very difficult problem to solve and will need constant maintenance, but I think it's worth it if it helps people get started building awesome, high quality things faster.


I'm really surprised to see this as the top comment. I've spent my career specializing in most of your bullet points. Lately I've been meaning to start a tutorial series with either those concepts or general "learn to code" kind of stuff. Clearly there is more interest in the operations type content than I would have guessed.


> I'm really surprised to see this as the top comment.

Me too. I consider most of these trivial too. But there's another aspect. Many things (version control flow, release model, rollbacks, etc) has to take into consideration and will inevitably affect the workflow, meaning the way engineers write code (feature flags? dynamic config? gitOps? what about rollbacks? Do we keep the tip of the branch synced with prod or no?).

The _state of art_ is different based on things like: Monolith or micro-service (like smaller, well defined scope)? Is the app written in Java, NodeJS or Python? Do we have 5 developers, 1 or 400? Do we need to testing because the app is handling medical data or we don't care if we don't case because our SaaS doesn't handle sensitive data? Do we need integration tests? Do we care about raw computation perf? Mem leaks? What about testing thresholds?

All the above and many more, depend on business goals and domains, engineering cultures and less obvious intangibles. These evolve "naturally" over time.

There's no "state of art", just business needs. The "state of art" is the sweet spot between engineering velocity and reliability, which is a moving target anyway :-)


For me, it would be great if the tutorial can focus on minimising the amount of work required to maintain or update the site while still retaining flexibility.


I'm not sure if you will see my other comments in this thread, but please check them out. Molecule.dev covers all of this.


This is actually exactly what Molecule.dev is all about. All of the documentation, guides, and tutorials are written with both teams and individuals in mind.

It includes detailed step-by-step guides for every little thing you need to know to develop, release (and rerelease) your app on every platform you've selected, using the tools you've selected. It also covers many edge cases and obscure issues which we know that you will probably run into.

It's written for developers of varying levels of experience so that any member of the team (present or future) can quickly jump on board and get started building and deploying.

It also includes a (very meta) guide which explains how to update the guide itself and regenerate new documentation as you (and your team) add to it for your own purposes.


Where? There seems to be no way to access this documentation without spending hundreds of USD on a code platform.


Thousands of hours have gone into building Molecule.dev over the past year, which itself is the culmination of tens of thousands of hours of experience, honing in on the absolute best tools and approaches. It makes no sense to give it all away for free. As much as I would love to live in a world where we could all freely share our hard work like this, people need to make a living somehow.

Starting this week, however, we'll be publishing regular articles about the inner workings, design decisions, and architecture, among other things. We may actually cover some of the core basics and release sample code with documentation. We'll probably publish at least 2 articles per week.


I understand that, but it makes it seem off-topic for this thread. There are other off-topic (but possibly great) for-profit courses and such too, and no one's bringing them up because that's not what the Ask HN is about.


Maybe we can release the documentation and tutorials separately, and possibly some of it for free. It's much better if you have all of the code though!


Yes to all but these three that seem out of place:

- How to integrate analytics

- How to integrate ads respectfully (of your users)

- How to integrate paying contents


I like to read articles by people who feel they have something that's important to say. If you don't know what you should to write about, then anything you write is probably going to be pretty uninspiring. Good writing comes from a place of passion and urgency, a real drive to inform people about something that the author thinks is worth reading.

This might be an answer you don't like very much, but seriously, all the best articles that I've read and shared in the past have been been things that the author would probably have felt compelled to write even if no one bothered read their work. I can't imagine that soliciting for ideas really works.

I think this is the main reason why I've always failed to be the blogger I aspire to be. There are few subjects that I care enough about to write consistently on. It's weird, because I post on the web a lot and I feel like I'm pretty passionate about web stuff. It just doesn't manifest in the form of blog posts though.


> all the best articles that I've read and shared in the past have been been things that the author would probably have felt compelled to write even if no one bothered read their work

I've felt compelled to write this question on HN. Even if I don't draw anything for me, maybe someone else will. Additionally, remembering I asked this question and didn't get inspiring answer, I might finally be compelled to write my own thing without any other questions. You never know.

And if we already do meta talk: 1. Every rule has an exception. 2. Always do most exciting thing, today it's asking a question, tomorrow it's writing an article. Rule 1 works for points 1 and 2. And also works for your impressions about best articles. :)


I’m an individual contractor. I design and implement cloud architectures that replace entire teams of developers and charge way above the average. Yet the things I do seem so obvious to me that I can’t help but wonder why they didn’t see that obvious solution I’ve implemented. This idea continuously make me doubt if my experience is valuable enough for other engineers.


Yet the things I do seem so obvious to me that I can’t help but wonder why they didn’t see that obvious solution I’ve implemented.

Practically everyone who has a decent amount of experience delivering something feels that way. Usually it's a combination of the original team not having as much experience, or that the situation at the time didn't allow it (lack of resources, incompatible acceptance criteria that no longer apply, etc), or that you've missed something important that actually means the solution you're going for is the wrong approach. Understanding which it is is hard.


Not that hard if the solution is about gathering and transforming data. The benchmarks are quite definitive: servers cost, performance, correct output.


> I design and implement cloud architectures that replace entire teams of developers

I'm curious: How do you replace entire teams of devs by choosing cloud architectures? Is it because cloud architectures bring so much stuff out of the box that is otherwise implemented in a custom way by individual developers? What would be an example?

Edit: Found your blog post about it: https://kulikalov.com/how-to-make-sense-of-cloud-architectur...


Yep, stuff out of the box, correctly wired and monitored


> why they didn’t see that obvious solution I’ve implemented.

Not trying to be bring you down or anything, but the most likely answer is that every senior engineer in the company knows what needs to be done but lacks the political capital/will/etc to implement the change.


> all the best articles that I've read and shared in the past have been been things that the author would probably have felt compelled to write even if no one bothered read their work

I beg to differ. Might be true for the most interesting articles, but the most useful articles are day to day stuff like How to do X in Y imho.


> all the best articles that I've read and shared in the past have been been things that the author would probably have felt compelled to write even if no one bothered read their work

Now I am curious of some examples of such articles. I like good articles that makes me think.


I like this comment a lot.


What I would find interesting is a page which lists all steps to be performed on the command line to create a web application from scratch.

Say we start with a fresh Debian install, the first line might be

    apt update && apt upgrade
The second line might be

    apt install php
Or Python or Node. And then the commands to create the project directory, switching to it, installing a webserver etc would follow. At some point there would be a line

    echo "<h1>Hello World</h1>" > index.php
At this point, we accomplished serving a static page.

And then line by line, a full web application is created, with routing, templating and user accounts. With no other tool than the command line. So the page would never say "Click on this then click on that..." or "Depending on your environment...". No, you could simply copy every line, paste it to your terminal and thereby create the exact same application.

Ideally the page would have one column of commands for every typical approach like Django, Flask, Laravel, Symfony, NextJS etc.

I would expect this page to start with just one approach - say Django. And then accept pull requests from experts for the other approaches.

So we would have side by side examples of what steps are needed in different environments to create a typical web app nowadays.

I had this idea for a while but so far did not get around doing it. If someone wants to collaborate on it, hit me up.


I feel like there are so many of these tutorials. The problem is that a person who wants to learn React generally does not care about Debian and something like apt update && apt install nginx.

Then depending on who's writing the tutorial, the content ranges from "create a VM and issue these commands" to gcloud commands to spawn VMs.

Usually, when a student doesn't know anything about React, they won't know anything about Debian, and the whole tutorial will go over their head. Alternatively, it will be highly shallow. Or, usually, both.


The difference to the other tutorials is that this one would not have prerequisites in terms of tools and services. It would not require anything but to copy+paste lines to go along. And that the format of shell commands makes the different approaches very easily compareable. And reproducable. You can put all of the commands into a script and have your own automated template to start new projects.

A single Docker container can be used like a fast, lightweight VM. And from there on it is just copy+paste.

So on a Linux machine the process would be:

    1: docker run -v $(pwd):/var/www --rm -it -p 80:80 debian:11-slim
    2: Copy+Paste the lines
    3: Enjoy the running web app


Docker is a tool prerequisite. For example, on a SELinux system, docker run -v $(pwd):/var/www will cause issues (because you need -v "$(pwd)":/var/www:z). Also, isn't -v deprecated?

What I'm highlighting is:

* The knowledge depth and time required on your part to maintain the text such that it works on all supported systems

* The fact that you're depending on a number of tools that might become obsolete quite fast, which might throw a wrench into your text.

** For example, Docker stops supporting CLI due to licensing. Linux splinters off to podman, Windows creates its own tool, macOS users will generally continue working with Docker. You'll then be forced to migrate to a different tool, like Vagrant.

Rather than create a text that's a "bring your own developer workstation", create a webpage that I pay $15 for monthly, you record a video explaining a concept, and then you have a button that says "spin up a lab for X". This throws me to a controlled environment, e.g. in AWS, where you tell me the exact steps that will achieve what I want to achieve.


On the other hand , a tutorial like this needs to be actively maintained as packages come and go . It’s essentially a documentation


Yes. I would expect the article to become an "eternal cornerstone of web development" which evolves with the stacks.

After a few years, the history if it would be very interesting. It would show how much maintenance a minimal web app based on the different approaches needed.


Apart from the Debian command what else you need to learn from Django? I'm writing python based web application development tutorial here https://rajasimon.io


Writing code as a sequence of "echo ... >> ..." lines would be awful. It should at least use a text editor (doesn't lose the copy-paste functionality).


With a Texteditor you need to "describe" the process. Like "Open your text editor and create a file called /etc/apache2/sites-enabled/000-default.conf then put the following code into it ... then save it, make sure the access rights are... make sure the file encoding is..., make sure it does or does not contain a final carriage return ..."

With the shell, all of this can be combined in one command that you can easily read, understand, copy and paste and which is exactly reproducable:

    cat << 'EOF' > /etc/apache2/sites-enabled/000-default.conf
    WSGIPythonPath /var/www/mysite
    <VirtualHost *:80>
        WSGIScriptAlias / /var/www/mysite/mysite/wsgi.py
        <Directory /var/www/mysite/mysite>
            <Files wsgi.py>
                Require all granted
            </Files>
        </Directory>
    </VirtualHost>
    EOF


But no one will want to exactly copy and paste everything from the tutorial (e.g. you'd put the name of your thing instead of "mysite") so by doing it that way you're forcing people to copy and paste it into a text editor, make the edits, and then copy and paste into a terminal. It all seems overly complicated. To be editable and equivalent to your example, all you need is two instructions:

1. Run this:

  $EDITOR /etc/apache2/sites-enabled/000-default.conf
2. Now paste in this:

  [file contents]
Access rights are a separate command in both methods, and if you're really concerned about file encodings (seems unlikely for this sort of thing), that's either an editor setup step at the very start, or one command to convert in either method.


To test it, I would copy all commands verbatim and play around with the running web application afterwards. Say to try Django or some other framework which I have not used before.

Even just reading it would give me an unambiguous insight into the concepts of the framework.

To "fork" it, I would copy all commands into a shellscript and then change something like "mysite" via search+replace. In vim it would be: :%s/mysite/yoursite/gc to change all occurances of "mysite" to "yoursite" and be shown each replacement before it takes place.


That sounds like a Dockerfile


Similar but somewhat different. You would normaly not have

echo "<h1>Hello World</h1>" > index.php

in a Dockerfile.


I want to work on this . This is interesting.


I think an under-served market is "intermediate to advanced programming for people who didn't study computer science but can already write half-decent Python and maybe some SQL, JavaScript or Matlab/Julia/R".

People who are fine with control flow, git, unit tests etc, but who would be lost if you start talking about things like state machines or depth-first search.

I'm largely talking about myself here, but I've worked with dozens of colleagues in several different jobs who would also match this description.


“I think an under-served market is "intermediate to advanced programming for people who didn't study computer science…””

I find this too. I’m self taught and have made a lot of good projects with blog tutorials and SO. Python has let me do a lot quickly, but I get stuck on some odd things.

Last time it was data structures. For a project I was expanding, the data structure was insufficient. I imagined there must be more complex data structures to solve the challenges, and I asked people for this. Lack of response helped me realized my thinking was wrong. Then I realized I could do what I needed with SQLite. Haha.

Right now I’m stuck on an aspect of Django. Django is a Python module. When I want to add another module to modify how Django behaves I need to override in my code. It’s all too complicated to imagine for me. Example, adding wiki pages to django by adding django-wiki module, then adding tags to the wiki pages by adding danio-tagulous. I know this is some kind of class override, but I just can’t imagine it.

Also, How to think through adding API data to your project? Like swagger.

For me it’s about thinking or visualizing how to put my code together with other people’s code. And once in a while I ‘imagine’ what a solution should be, and I make everything more complicated than it need be.


>> Right now I’m stuck on an aspect of Django. Django is a Python module. When I want to add another module to modify how Django behaves I need to override in my code. It’s all too complicated to imagine for me. Example, adding wiki pages to django by adding django-wiki module, then adding tags to the wiki pages by adding danio-tagulous. I know this is some kind of class override, but I just can’t imagine it.

Can you expand on what you're trying to achieve? It sounds like it's a mixture of frontend and backend in Django?

>> Also, How to think through adding API data to your project? Like swagger.

Tell us more what you mean. What's your end goal?


> “What's your end goal?”

I’m not looking for problem solving, and I’m not going to discuss specifics here. I’m describing for the OP a difficulty I have in programming, which I assume is due to a gap in my education. You’ll have to use your imagination.

The best I can do to explain what I’m struggling with is confusion over levels of abstraction further from the code I’m writing—write some code, then expand it by importing someone else’s code and then import another piece of code to expand the first import—it’s turtles all the way down.

Dealing with APIs isn’t as terrible as that, but I could use some better language to describe these special cases. I’m also bad at reading other people’s code on GitHub and understanding what they’re doing—for example. But of course I understand my code.


This is something I plan to start writing about. There isn't enough intermediate and advanced material. I've also ran into too many "senior" programmers that not only lack some of the topics you mentioned, but also fail to grasp the importance of structural things that would improve overall code quality.

How's that saying go? Show me a programmer with 20 years experience, and I'll show you a programmer that did the same thing twenty years in a row.


I think you might find this page useful: https://teachyourselfcs.com/


This would be great, because I definitely match this description


Earlier tonight I was making a programming challenge list for experienced programmers. These are all small tasks but the question is can you do them.

Create a

1. Mandelbrot

2. Julia set

3. Ray tracer with shading and shadows of a few simple spheres

4. A simple virtual machine

5. Rewrite the first three programs in the virtual machines assembler

6. A simple language such as Forth for the virtual machine

7. Rewrite the first three programs in your implemented language

All of these 7 tasks together will likely take under 2,000 lines of code, maybe even under 1,000.

If you know what you're doing, each one individually should take under an hour.

Doing a write-up about your experience with this would be great. Each one of these tasks has tradeoffs and can reflect personality and approach.

This is version 1.0 of this, and I just came up with it a few hours ago so I'm open to slight modifications (perhaps an extremely easy game instead of one of the fractals)


> If you know what you're doing, each one individually should take under an hour.

In other words - the second or third time you do it, it should take under an hour.


I'm curious -- is this realistic? Can most experienced programmers really do all this? I've been coding for a few years and I can do maybe one or two of these.


> Can most experienced programmers really do all this?

I hope not.

The point is to give experienced people challenges that are achievable but are both hard and simple


I can't speak for other experienced programmers, but for me (28 years experience)... I could do all the things listed, but I would not finish any of them in less than an hour.


"How to read an error message."

This would help countless people new to development. Lots of systems (I'm looking at you, Java) throw up vast splats of tracebacks. Others chunder out great chunks of poorly digested code. Sometimes daunting even for experienced people.

An article with basic advice about looking for the one or two useful lines in error messages would be great.


In my experience (teaching university students), few of the people who need such an article most would read it, or even go looking for it. Maybe some experienced people might, but most of those will figure it out for themselves.

I think most beginner programmers treat every error message as simply "you screwed up", and reading the error message and gleaning useful information from it doesn't occur to them as a possibility. That knowledge can come from it being explained like you suggest (but in person with their actual problem is better), or from them sitting down and puzzling it out. If you haven't been through this though, and don't know what kind of information is available in error messages, you won't go looking for an explanation of how to find it.


My experience is that you learn reading Java stack traces by reading Java stack traces. There's nothing to it other than the initial stress of wall of text. Not sure about other languages though.


Case studies. For instance, Apache spark real life case study, why it’s the best, what are alternatives and what would be the cost breakdown for using it on bare metal vs SaaS like Google Cloud Dataptoc


One more thing, as a self-taught programmer, I struggle to understand other people's code. I would therefore like to read more about how programmers _inspect_ code so they may modify how it works. For example, let's say you find a third-party package (I'm using Python, so we call these modules), and you want to fork some particular package so it uses a database instead of config files.

Now I get the general idea of what I could do--clone the code, start editing it, setting breakpoints, walking the code execution, and essentially rewriting making their code my code. But it's a tangled web, no? Not easy. And then there must be (?) shortcuts? Plus, I'd like to read about the terminology and methods so I can search for other people's tutorials.


> And then there must be (?) shortcuts?

The shortcut is that if the code is well-structured, the use of config files should be isolated and clearly visible and you replace that without touching or needing to step through the rest.

But that depends on the code structure.


It seems that Nix can be used as a build tool for building e.g. rust applications. A good step-by-step for that would be interesting, particularly one that spelled out the advantages over existing tooling like Cargo.

Most things I found when my interest was piqued were from the perspective of building or running NixOS, which is (for now) much less interesting to me.

(Edit: If anyone feels like they have the technical knowledge but not the writing skills, I'd be happy to team up!)


I don't know exactly how to name it but... Something along the lines of tutorials/courses how to make code for Error Handling (front/back), Defensive Programming, Observability, Tracing, Contexts/Stores at the Airbnb/Spotify/Basecamp level. That means, instead of hello world, show the best practices and all of the things that makes those things perform well, be maintainable.


I wrote a small guide on that: https://kulikalov.com/minimal-viable-logging

Not Spotify, but I have several decently loaded projects running with this setup for years.


A blast from the past: I would love to read about deliberate use of Perl 5 without CPAN, or with as little CPAN as possible.

Being a fan of minimal, clear languages, Lisps, Forths, Rebol etc, I've somewhat unexpectedly found myself immersed in the stuff by Perl community (perlmonks.org). I seem to like the free-form madness that surrounds this language (and the Monks), and Perl's linguistic roots and Larry Wall's thoughts on this are very interesting. Sigils and the verbosity strangely make sense to me, etc.

But, installed Perl is Big, at least compared to Picolisp, Rebol, or Lua.

I read about Microperl [1], but seems like it hasn't found (didn't find, in its day) wider usage. This philosophy -- deliberately writing Perl with a minimal amount of external dependencies -- doesn't seem very popular, aside of one-liners, which is a different thing imo. I wonder why. I've found a few contemplations [2, 3], but not much. Are people who have loved Perl first and foremost because of its syntax, semantics, TIMTOWDY etc, a tiny minority as compared to those who were dug in primarily because of CPAN?

And I wonder if Perl 6 (Raku) will be any different in this regard -- will its design encourage or favor minimal uses or systems a little more?

1: https://www.foo.be/docs/tpj/issues/vol5_3/tpj0503-0003.html

2: From 2018, "I want Circuit Perl now!": https://www.perlmonks.org/?node_id=1210076

3: From 2003, on Microperl: https://www.perlmonks.org/?node_id=228040


SQL.

I'm continuously surprised by the ad-hoc manner in which devs use frameworks not understanding what the syntax they wrote means to the database. Many are confused by joins, or vs left-joins, and if a query runs slow have little idea how to index or change their schema to be more appropriate.

While we're here I'd also say data modelling. The DB is not meant to have a row-to-screen/page cardinality matching, unless you're a startup using MongoDB (or other document store).

The third one would be about API design. There are many blog posts that discuss one or two specific aspects of a particular API type (REST, gRPC, GraphQL) but it would be great to pick one of them and have it all lair out.

There may be print books that cover the above, but certain important topics always seem to fall in the gaps, like how exactly does one bound their microservice context? Most books gloss over this with a hand-waving trio of Order, Product/Widget, Customer.


Coming from a ML domain, I feel there is so much terminology and its duplication floating around which could be better explained, maybe with an example or a picture (or even a simple howto). The technical debt is just too high.

For example, hundreds of papers talking about 'inductive bias' or 'SE(3) operators' and what not. There isn't even a general boundary between unsupervised and self supervised learning (Remember Yann Lecun stepping in one such debate but without a conclusively clear demarcation). Very few actually try to explain a view that general practitioner can connect (with some basic exposure). Google maintains a ML glossary but that sorely needs some updation beyond the very basic stuff.


I wish there were more good courses on AR and VR development, especially for non-gaming applications. I'm not an engineer but managed to learn web dev thanks to amazing courses and YouTube channels, but find it difficult to kick start my AR projects


Something I've seen multiple times from junior developers is an expectation that the technology will tell them how to fix their errors/exceptions/unit tests/problems.

The technology in IDEs, the things you Google, the bugs you get, stack trace messages, none of these things TELL YOU WHAT TO DO OR FIX. They are clues or evidence. You have to bring the understanding and intention.

I expect that some people disagree about this being a problem, but I've seen it enough times to recognize it. Senior developers need to remember that they were not always senior.


Making a Pinephone app start to finish/into some app store.


I find it hard to read manuals and documentation. I learn much better from seeing real code, and then trying and playing with it myself.

I’ve had an idea for a while that it would be interesting to document a computer language with a complete set of example code. This example code would exhibit all the language’s functionality. It would be written with best practices in mind.

The code wouldn’t necessarily need to do anything useful, The goal would be the code itself.


There's metric tons of tutorials that would benefit a lot by delving beyond "Getting started" and the obligatory Hello World construct, to dealing with implementing a more real-world use case, and showcasing the various best-practices to the language / lib / framework along the way.

So many projects list a gazillion features on their site, and then leave you with a "Good luck! The features are in the code base".


It does not matter what one likes to read or watch. What really matters is what you can teach or share. There will always be a market of any niche, especially related to dev.

I myself maintain a blog and run a Youtube channel in local Urdu language. When I started, I did not think what others want. I shared what I loved and could do on my own.

As long as you are original, authentic and honest, people would enjoy even a Hello World video by you.


Some topics that I would find of interest:

OpSec/Tradecraft for Developers

The metaphysics of CS/stats/DS/ML/etc. (I have a vague impression that the Bayesian vs. frequentist argument is just one tip of a multifaceted iceberg)

Protocol design and File format design

Game Theory as applied to de jure and de facto standards-making (incl. network effects, adversarial interoperability, etc.)


I am not sure what you work on, but here are some resources I like to see.

* A in-depth, conceptual explaination of HTML/CSS layout and common UI idioms, so that I don't have to google something every now and then when making a website

* Back-end security related topics in one place. Various type of attacks and edge cases. (OWASP comes quite close I think.)

* Using Databases efficiently.


I’m just a student but I would love some content around how to get started with serverless. Also comparing and contrasting different front end or UI frameworks and what you’ve seen that’s worked well or poorly at scale.


Fireship.io goes over these things superficially (in a good sense)


this seems like a good thread to piggyback on. Could I get some links to " official development blogs"? I recently bumped into the one by Etsy (http://codeascraft.etsy.com/) and I'm sure there are many others.

I find the first hand story of how different architectural decisions turn out in real world scenarios are way more valuable than all the blogs out there writing about any new hot piece of tech. I'm curious what you found interesting and even check regularly.


https://github.com/kilimchoi/engineering-blogs


Things like:

-How to do modern frontend dev without installing almost a Gb of transient onliner JS deps.

-Modern Frontend development for Backend devs.

-Mobile apps development without installing huge frameworks and heavy tooling.


I would also like to see this along with all the boring but important security stuff. And by boring security stuff, I mean SAML in a ADFS environment with those frameworks techniques. And a sane upgrade and update strategy that doesn't mean that 90% of the effort will be spent on lifting up package versions.


I'd like to read about developing in the post JavaScript web


Sorry, what's the post JS web? Are you talking about WASM?


Perhaps. I am not sure if WASM is going to be it.

It certainly could be


A tutorial on modern web Architecture and infrastructure . Something that writes on how to build them using proprietary software and also open source equivalent of each


i am looking for frontend course/tutorial that can show me how to create real world dashboard with javascirpt however all i find is bits and pieces scattered all over the internet. Most of the javascript tutorials want to teach language syntax which if you already know some language is kind of useless. May be i am not able to search properly with the right keywords.


Hacking open source. I would love to see architectural overviews and code tours of major open source projects


Here's something very similar to that: https://www.aosabook.org/en/


Not on your plate, but i would pay some good money to a good course/book about openresty!


More "Build X from scratch" tutorials, not those downloading 500Mb dependencies at the start.


thorough explanations of FP concepts like algebraic effects, linear programming, dependent types


I wouldn't describe those as being "FP concepts" - though the more you get into FP you'll run across more "academic" CS where you will see those concepts, sure.

* "Algebraic effects" are still a research topic, they aren't a feature of any production programming language today (as far as I'm aware): https://overreacted.io/algebraic-effects-for-the-rest-of-us/ - did you mean "algebraic data-types" instead?

* "Linear-programming" refers to a class of optimization problems in mathematics and statistics, it has little to do with FP.

* True dependent-types are... complicated (and seen in theorem-provers more than in any language); when most people say "dependent-types" they often really mean just "refinement-types", and while refinement-types are a feature of many FP languages, they aren't exclusive to FP: in fact you can implement practical refinement-types in any conventionally-typed (even non-FP) language with cheap value-types and user-defined implicit conversions (like C#, C++, Swift, but not Java).


I wound be glad to find more about Perl and xml parsing for huge file size.


Electronics, Microcontrollers


Defining an OS environment beginning to end in Guix or Nix.


a really in depth one on developing AI to play computer games.

It seems like it'd be a fun pet project.


Chromium development




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: