Books: Operating Systems/Database/Networking/Computer Security/Computer Architecture textbooks, Software Engineering textbooks (Clean Code, Design Patterns, Designing Data Intensive Applications, Domain Driven Design as a short list off the top of my head)
Ask HN: What overlooked class of tools should a self-taught programmer look into
61–70 of 416 posts
Re: Ask HN: What overlooked class of tools should a self-taught programmer look into
#62Learning how to use dtrace / bpftrace [0] is very valuable if you ever need to get into serious systems profiling. There are some really cool data structures out there you might not know about. One of my favorite basic ones that I get a lot of use out of is the trie [1] (a.k.a. prefix tree). Very useful for IP calculations. Also look into probabilistic data structures [2], very amazing things can be done with them. […
DTrace is life-altering.
I keep hoping that someone will build a dtrace(1) CLI that transpiles to bpftrace.
Re: Ask HN: What overlooked class of tools should a self-taught programmer look into
#63Earlier quoted context omitted.
One of the worst problems with using windows (in my opinion) is that there’s no native GNU make.
Isn't non-native development on Windows a solved problem nowadays with WSL(2)?
WSL is currently horrendously (unusably, IMO) slow. WSL2 promises a 20x speed up, but it was already 100x slower than native Linux at some actually-realistic workloads that happen all the time when you're developing (e.g. `git grep`), so it's probably still too slow to be tolerable.
I had the opposite problem of wanting to develop some stuff for Windows from a Linux environment, and I settled on running a linux VM and copying binaries over by scping to WSL, which works reasonably well.
Re: Ask HN: What overlooked class of tools should a self-taught programmer look into
#64Makefiles. I always dismissed them as a C compiler thing. Something that could never be useful for Python programming. But nowadays every project I create has a Makefile to bind together all task involved on that project. From bootstrapping the dev environment, running checks/test, starting a devserver, building releases and container images. Makefiles are just such a nice place to put scripts for these common tasks…
fabfile.py (Fabric) could be used as a Makefile in Python. If you don't ever need to ssh to other machines ti run your tasks, you could use pyinvoke library directly (tasks.py). https://www.fabfile.org/ It is easy to add command line arguments to the tasks, configure them using files (json, yaml), environment variables, to split the task definitions into several modules/namespaces.
Having used fabric in the past, I've always found it just as easy to use a shell script and make files.
There's always some level of bootstrapping a project (installing packages/software, compiling libraries and dependencies) where it's easier to just to write a shell script than to program python to do. E.g. How do you get fabric installed on a system?
There's also been this longevity of sorts that Make seems to have gotten right. People just keep going back to it because it's simple.
Re: Ask HN: What overlooked class of tools should a self-taught programmer look into
#65Event-driven, asynchronous, programming
Here's a valuable addition to your toolkit of mental models for programming: Event-driven, asynchronous, programming (in the style of ES6 Javascript or a similar language. )
Some suggestions about how to learn the basics? tutorials on...
-- building a so-called "single page web app" with a framework like vue.js or even jQuery.
-- node.js to build a complex back-end server without using a threading model)
-- React (to build an interactive program to run in a browser)
Re: Ask HN: What overlooked class of tools should a self-taught programmer look into
#66A few decades ago, a new programming environment exploded: the web. Looking for a ridiculously useful tech stack? Look no further: HTML, HTTP architecture, SQL backend... a guide written at the time: http://philip.greenspun.com/panda/ Paul Graham also wrote about why the web was such a deal, IIRC in the Beating the Averages essay. In particular: you can use whatever tools you want and avoid deploying to client machin…
PostgreSQL + PostgREST + react-admin == fantastic stack.
You can write an entire application in SQL and PgPlSQL but using an HTTP JSON API as the interface with a static and responsive BUI.
This allows you to be extremely agile in development and ops (because, e.g., you get to use logical replication).
I can't say enough good things about this approach.
Re: Ask HN: What overlooked class of tools should a self-taught programmer look into
#67https://dataintensive.net/ I can't recommend this book enough. I have a CS background, and still had quite a few "I can't believe this thing has been hiding in plain sight!" moments while reading it.
I'm now torn between reading this one first or the Architecture of Enterprise Applications.
I loved Designing Data-Intensive Applications. It gives you the reasons why NoSQL databases exist and the problems they solve. Moreover it gives you reasons to select one over another. It's really excellent and one of my top two CS books
Re: Ask HN: What overlooked class of tools should a self-taught programmer look into
#68Makefiles. I always dismissed them as a C compiler thing. Something that could never be useful for Python programming. But nowadays every project I create has a Makefile to bind together all task involved on that project. From bootstrapping the dev environment, running checks/test, starting a devserver, building releases and container images. Makefiles are just such a nice place to put scripts for these common tasks…
In 2019 Makefiles are a useful tool for automating project-level things. Too often webapps will require you to install X to install Y to run producing artifact Z. Since Make is old and baked and everywhere, specifying "make Z" is a useful project-level development process. It's not tied to a language (e.g. Tox) nor a huge runtime (Docker). Make is small enough in scope to be easy, and large enough to be capable without a lot of incantations.
The big downside of Make, alas, is Windows compatibility.
Re: Ask HN: What overlooked class of tools should a self-taught programmer look into
#69Formal methods.
It took me nearly a decade of working in distributed systems to be introduced to TLA+ and other tools in this space. Until then my knowledge had been built from textbooks describing the fundamental data structures, algorithms, and protocols... but those texts take an informal approach with the mathematics involved. And since I was self-taught I was reading those texts with an eye for practical applications than for theoretical understanding. I had no idea that a tool existed that would let me specify a design or find potential flaws in systems and protocols, especially concurrent or parallel systems, with such ease.
I think type theory and category theory have also been great tools to have... but I think mathematics in general is probably the more useful tool. Being able to think abstractly about systems in a rigorous way has been the single-biggest booster for me as a practitioner.
Re: Ask HN: What overlooked class of tools should a self-taught programmer look into
#70Get good at math. It'll serve you well and never go out of style.
Math is a bit too broad. From personal experience, the most relevant topics for programmers are Linear Algebra and Discrete and Combinatorial Algebra.
Eh I mean, I think there's a certain discipline that comes with studying any branch of math to a certain degree of rigor. But yes, linear algebra and discrete math are probably the most useful. I think control theory and optimization are under appreciated amongst programmers though.