HN user
I personally love watching the live coding sessions by Andrew Kelly, creator of Zig, regarding progress with the language/compiler. Archived videos available on Vimeo
I personally use Setuptools (.py and .cfg) with pyproject.toml for the build settings.
Last I used poetry was a couple of years ago, and IIRC it didn't gel well with Conda environments.
Well, the author did post the entire email thread (redacting information that may be proprietary) on Imgur.
Personally, I think the Replit CEO could have explained what the specific issues were before threatening to sue. Since there was no explanation on the CEO's part, I think it's perfectly warranted for the author to make this public.
Part of the function of time is to filter out the timeless from the merely timely
This is such a beautiful observation.
As a kid, I wasn't into "old" fantasy and scifi, but recently have started reading them. And I must say, there are a lot of authors with some beautiful foresight, especially Le Guinn: the entire Earthsea Cycle talks about some deep psychological introspection, about how power dynamics can affect different sects of society differently, about the notion of "inherent evil". This stuff is as timeless as human society.
If you loved Tales Of Earthsea, you _must_ read the last book in the Earthsea Cycle: The Other Winds. It takes a very introspective approach to the notion of mortality and immortality, which ties in with the importance to the _names_ of humans, dragons, animals, and other objects. It's phenomenal, to say the least.
I suffer from severe depression in general and social anxiety around more than a handful of people, and have talked to therapists regarding this. One huge benefit of therapy is that I was quite quickly able to answer the question of __why__ I feel the way I do, especially around new people I meet. But it is a whole another thing to actually being able to "fix" it. The way I think about it is that I know what the problem is _in theory_, but have no idea how to come up with a _practical_ fix for it.
When I was less depressed, I was able to join a local D&D group, go for bar trivia nights, etc. but as I became more depressed/anxious/stressed (coz of personal and professional situations), it became harder to push myself to become sociable and not get anxious around crowds.
So I think the main point that the parent comment is trying to say is that people need to recognize that problems that may seem to have simple and straightforward "solutions" (like "have you considered therapy") are significantly harder for some individuals purely due to other mental health issues.
I am not trying to fault you, but it is a thing I see in a lot of my friends/peers/relatives is that it gets harder to understand how different mental health issues affect different people in incredibly different ways.
I loved the DMT story, and I would love to know more about this Owl drawing tutorial you recommend. :F
In most cases, what you are looking for is a language server like `clangd` (works for most compilers) [1].
You can find a Language Server Protocol implementation for your editor at [2] (I don't think it lists __all__ clients, but it should include the most popular ones).
EDIT: I realized that this is a vague answer, so let me clarify.
An LSP implementation (especially clangd) provides actions like `go-to definition` or `find references` that you would find in full-featured IDEs like CLion (which is also amazing BTW). Since you mentioned vim, I am guessing you use it and don't necessarily want to let go of the hand-crafted vimrc you have created. Adding an LSP plugin to Vim is incredibly easy and gives you these "IDE" features with customizable mappings.
If the issue is with including transitive dependencies that are in your own codebase, then you should annotate the public interface header to the implementation details with IWYU Pragmas [1] that export the implementation (for example [2]).
If this is in third-party libraries, you can use IWYU Mappings [3] to map the "private" headers (usually the transitive include) to the public interface. An example that I use for the PEGTL library [4].
[1] https://github.com/include-what-you-use/include-what-you-use...
[2] https://github.com/anand-bala/signal-temporal-logic/blob/800...
[3] https://github.com/include-what-you-use/include-what-you-use...
[4] https://github.com/anand-bala/signal-temporal-logic/blob/800...
I've found that using IWYU Pragmas [1] for codebases you own and IWYU Mappings [2] for third-party libraries __almost__ entirely eliminates weird IWYU suggestions (there are a few annoyingly stupid suggestions from the tool I just ignore).
I've also recently been making libraries I write compatible with users that run IWYU by annotating all public headers with IWYU pragma comments that export symbols/transitive includes correctly, etc.
[1] https://github.com/include-what-you-use/include-what-you-use...
[2] https://github.com/include-what-you-use/include-what-you-use...
While I agree with a lot of the points that the author is making (especially #5 regarding major labels feeding into the "viral hits" hype), I feel like the author is discrediting a lot of musicians that actually care about the music they are making.
(Disclaimer: Purely anecdotal)
An example of a band I feel is highly underrated is Misterwives [1]. I've been following them since ~2015 and have listened to every album released, watched them live at a concert, and at a "live" pandemic virtual concert. And I think they are phenomenal, both, via headphones and live. And these are artists that spend a lot of time perfecting their art. And only recently are they seemingly getting more attention.
The point I am trying to make is that there are artists that work their asses off trying to get their art known, but since they aren't really "viral" content worthy, they don't seem to be picked by the "best" labels. And this is a trend I see a lot in artists from more specialized/niche/indie genres like alternative music, jazz, and instrumental/orchestral, compared to artists belonging to the more generic "pop" music genre.
[1]: Website doesn't work without JS enabled, but I highly recommend listening to their albums. https://www.misterwives.com/
I am not sure what you mean by "false abstractions" in this article. Could you cite some concrete examples in the article that support your claim?
The author isn't claiming to go into a deep dive into C or C++. They are trying to talk about Rust. Your argument seems to be against the author's use of "C/C++" vs. "C and/or C++", which seems to me like some nitpicking, as the author uses "C/C++/Rust" later on. It isn't like they are pooling the languages as being the "same". Rather, they are talking about having similar, lower-level of control over "strings" as a data structure, as opposed to the primitives they seem to be in other high-level languages like C#, Python, Java, Go, Kotlin, Swift, or JavaScript.
As an ex-Sublime and ex-VSCode user, I realized that macros and Visual Block mode covers all my use cases for multicursor functionality.
Disclaimer: not a parent, but anecdotally curious as a child.
Give them video games. Problem solving, and creative button mashing as a must if you want to be good at a game. Then slowly extend to things like old laptops (get them to help you switch out the hard drive), etc.
This is a great point. Personally, the only reason I would want to switch to Emacs is Org mode but the muscle memory for custom Vim and Tmux keymaps is hard to give up.
The Rust rewrite of Coreutils (this post essentially) _is_ meant to be a drop in replacement for GNU/Coreutils. OTOH, ripgrep and fd are not "drop-in replacements". Rather, they are "replacements" that devs can use if they want to.
You have a valid point, but if the only formatting issue you will have is tabs, then running `zig fmt` on your codebase is pretty much a non-issue.
If your project is small, just run `zig fmt` on the command line.
If you have a large codebase, you can just incorporate it into your build process (similar to how clang-format and clang-tidy are used in CMake projects).
But again, if you have a large codebase written in Zig, you've probably already configured your editor to run `zig fmt` on save :)
I think the whole point of picking a language standard is to prevent the "space vs tabs" debate. Andrew is trying to standardize the language formatting issues, similar to tools like `rust fmt`, `gofmt` and `black`.
The "Spaces vs. Tabs" argument shouldn't be what stops you from joining hands and working together :)
Doesn't seem to work on Firefox mobile.
I came here for an intelligent discussion on why this article seems like some sales/marketing nonsense, but stayed for the Reddit-like quips.
(On the phone so forgive the possible typos)
I am not sure (1) is a very convincing argument. The subtraction of 1 internally is not necessarily gonna be there once the code gets compiled.
I will personally concede with you on (2), but it's still not very convincing considering that Fortran (a 1-index language) is still (arguably) the most popular language for linear algebra.
Personally, I feel "The Index Wars" are the same as the "Text Editor Wars": a matter for personal opinion.
Does anyone know if the Rust community has ever done anything original, though?
Depends on what you call "original". Is the Servo layout engine _not_ original because layout engines already exist? :)
Moving away from the rhetorical question, I think there are several reasons to rewrite something in Rust, the first and foremost being the huge improvement in memory safety/management. The other reasons are typically related to speed: C wasn't built with concurrency in mind, and trying to develop multi-threaded C applications that run in a cross-platform manner is not straightforward. On the other hand, Rust has the following:
1) Memory safety during concurrency [1]. 2) Multi-threading in the standard library [1]. 3) An amazing package ecosystem revolving around "crates". And there are several build specifically to make concurrency safe and easy to implement. [2]
[1] https://doc.rust-lang.org/stable/book/ch16-00-concurrency.ht... [2] https://crates.io/categories/concurrency
To me, it doesn't seem like it is LLVM doing the heavy-lifting as much as Docker/Podman (which are used through Cross). Maybe I am missing something...
I definitely agree with you that Zig and Go handle cross-compiling much nicer than the workarounds mentioned in this article. Personally, I prefer the cross-compilation mechanics of Zig over Go.
I am not sure if you read the article in it's entirety. The author's point is the exact opposite: while Ubisoft developers are ok with burning churches (which magically restore themselves), they do not show any of the other Viking raiding acts that have more broad implications. The author's problem is with the erasure of the actual viking culture, like slavery, and also with the (possibly unintentional) misogynistic views that the game portrays about weak, effeminate men, etc.
This is sooo true. I realized that there are actually some subreddits that are well moderated, and toxic stuff is quickly removed.
I also made it a point to stop browsing Reddit at the first comment that is either posted by a troll or is off topic in a bad way.
I am an avid (Neo)vim user. I love it and have been using it for the last 4-ish years. I know it's not a lot, but I _am_ in my early 20's. :D
I started coding only during my undergrad (computer engineer), so first editor/IDE was Eclipse, and then moved to Atom -> Sublime -> CLion. By the time I reached my 3rd year, I was writing C/C++, and took this course on Operating Systems. The course taught on the OS/161 teaching OS [1], which (at the time) used BSD Make and other magic, and I had no idea how to configure my CLion IDE to handle it. The course professor was a Vim evangelist, and actually dedicated a weekend to teach Vim for anyone who wanted to learn. Since, then I have been hooked. (Point being: I haven't existed for 40 years, let alone used Vim for that long, nor have I just been told. I think there is some comment in this post that compares learning Emacs/Vim to learning foreign languages, which I definitely relate to.)
Why I like Vim:
1. I can separate my text typing with text manipulation (if that makes any sense). 2. Cliche, but I love that I don't have to use my mouse. I don't necessarily care about the speed of it (I have RSI from using my keyboard too much, so I am actively slow) but having to switch to a mouse and then search for the button I want to click, etc. is a significant mental strain/distraction for me. 3. Command mode is not the same as keybindings in IDEs: I have used several IDEs (outside the ones I mentioned above) and I always found keybindings to not be intuitive and also involves having to press a bunch of unrelated keys. I think the reason why Sublime/Atom/VSCode have a Command Pallette is exactly for this reason, and IMHO, Vim does it better. 4. And, finally, the most important reason: I don't have to leave the terminal. I have a setup that uses Neovim and Tmux, through various high-quality plugins written by some really awesome people. It is seamless. I have latex compiling in the background, I can edit command line arguments to Clang without having to hop through multiple dialog boxes, and so on.
[1] http://os161.eecs.harvard.edu/
Edit: Forgot to put link to OS/161
Edit: Found out that the original website for the course I took is still up at https://ops-class.org/courses/buffalo/CSE421_Spring2017/
I personally use Flatpak for Discord and Slack. I used to have issues with my package repositories not being up-to-date too, but this is much more convenient.
This is true for Autotools projects, but isn't true for CMake, Bazel, Meson, and others. Let's take CMake for example, which is IMHO the most popular build tool: most modern CMake projects prefer to use the Ninja build system over Make.
And coming back to Autotools, some of the largest Autotools projects (see the GNOME ecosystem) has been moving/moved to Meson, which can also be used to generate Ninja rules instead of Makefiles.
CMake Generators: https://cmake.org/cmake/help/latest/manual/cmake-generators.... Meson: https://mesonbuild.com/ Bazel: https://bazel.build/
GNOME and Meson: https://wiki.gnome.org/Initiatives/GnomeGoals/MesonPorting
All the things you mentioned can be found in Zig! [1]
It's exception semantics are very similar to Go, but unlike Go, you have to handle the error. It has constructs like `defer` and `errdefer` which allow you do clean up at the end of the scope or on exception respectively. It has support for Generics and Metaprogramming without having to resort to preprocessor macros.
It just released v0.6.0 and is actively in development with an engaging and helpful community.[2]
[1] https://ziglang.org/ [2]: https://github.com/ziglang/zig/wiki/Community