Ask HN: Learn C++11 or Rust in 2022?

> using application performance monitoring software and analyzing query plans.

soo... tooling ? how is that different from using valgrind ? it's literally one click in my IDE to use it and it will show e.g. the time spent at each line of code directly in it.

> If you use Python and JS chances are you do some form of web development, where most performance issues have to do with I/O, and most of those I/O issues are caused by bad queries.

I don't know about this, what I know is that multiple times in my career I had people come at me with python software that was slow, and transliterating them almost line by line to C++ made them much, much, much faster.

Also I have all these apps on my system which apparently depend on python, none of them being a web app:

    Name            : 3dsconv
    Name            : anydesk-bin
    Name            : arandr
    Name            : asciidoc
    Name            : bind
    Name            : binwalk
    Name            : bpytop
    Name            : breezy
    Name            : carla
    Name            : ceph-libs
    Name            : cmake-format
    Name            : cppcheck
    Name            : cppman-git
    Name            : cython
    Name            : deluge
    Name            : deluge-gtk
    Name            : diffuse
    Name            : distcc
    Name            : fio
    Name            : fontforge
    Name            : fvwm
    Name            : fwupd
    Name            : gconf
    Name            : gcovr
    Name            : gdb
    Name            : gdb-common
    Name            : gdown
    Name            : glusterfs
    Name            : gnome-tweaks
    Name            : gobject-introspection
    Name            : gtk-doc
    Name            : i3-workspace-groups-git
    Name            : ibus
    Name            : inkscape
    Name            : iotop
    Name            : ipython
    Name            : itstool
    Name            : jack_mixer
    Name            : kajongg
    Name            : kig
    Name            : kitty
    Name            : kitty-shell-integration
    Name            : libffado
    Name            : libixion
    Name            : libopenshot
    Name            : libreoffice-fresh
    Name            : libsearpc
    Name            : libsigrokdecode
    Name            : lldb
    Name            : mallard-ducktype
    Name            : meld
    Name            : mercurial
    Name            : meson
    Name            : mono
    Name            : mypy
    Name            : namcap
    Name            : node-gyp
    Name            : nuitka
    Name            : openshot
    Name            : pahole
    Name            : paperwork
    Name            : pax-utils
    Name            : pcsclite
    Name            : perf
    Name            : ps_mem
    Name            : pyalpm
    Name            : pyside2
    Name            : qemu-tools
    Name            : reflector
    Name            : repo
    Name            : rubber
    Name            : samba
    Name            : scons
    Name            : seafile
    Name            : setconf
    Name            : smbclient
    Name            : smem
    Name            : solaar
    Name            : speech-dispatcher
    Name            : tellico
    Name            : thefuck
    Name            : thonny
    Name            : torbrowser-launcher
    Name            : udiskie
    Name            : virtualbox
    Name            : yelp-tools
    Name            : youtube-dl
    Name            : yt-dlp
    Name            : zim

incidentally, my day to day experience definitely does not classify any of the software I actually use in the "fast and enjoyable" category, except zim and tellico. Like, just launched a couple that I had forgotten about: solaar, a GUI for configuring logitech mice, and thonny, a minimalistic IDE for arduinos, etc. and they take actually observable time to start, on a 1k€ CPU, which I really find to be entirely ridiculous (and made me remember why I don't use them more).

Agreed but doing this at compile time would require some sort of pointer lifetime tracking in the compiler. Don't know how much of this is feasable without going "full borrow checker", but static analyzers for C do a similar thing, by far not as watertight as Rust of course.

The General Purpose Allocator can optionally catch use-after-free by not recycling virtual memory addresses, not very efficient for small high-frequency allocations of course, but then Zig isn't an OOP language either (where it would be common to create and destroy massive amounts of tiny objects).

Because smart pointers are still pointers under the hood. You're forgetting the time before you know what pointers were - people coming from higher level languages don't immediately grok the concept. By teaching them automatic memory management patterns like we use in C++ without teaching them why you need such things, they'll never fully understand the code they're writing.

It's like the "I know React but not JavaScript" crowd all over again.

If you think RAII is about smart pointers, you really don't understand it.

RAII is about resource management, regardless of where those resources live on.

Heap allocated, OS handles, indexes on a fixed sized buffer, network sockets, ...

> ...but static analyzers for C do a similar thing..

Exactly, which begs the question why bother with Zig at all.