Hacker News: int0x80

New comment by int0x80 in "The life and times of an Abstract Syntax Tree"

int0x80 — Fri, 03 May 2024 12:09:44 +0000

There is one common pattern which is required in many use cases when working and representing ASTs - having a `parent` node, or having access to parents and children. This complicates ownership implementation.

Additonally, is essential to provide an API to transform trees or even construct new ones using immutable ASTs like implemented in many compilers eg .NET Roslin or typescript TSC.

New comment by int0x80 in "The Heart of a Language Server"

int0x80 — Sun, 31 Dec 2023 17:42:37 +0000

>In this formulation, a language server needs to just enough analysis to drill down to a specific node.

Does rust-analyzer compute semantic information on the fly and incrementally?

New comment by int0x80 in "Costs of running a macOS app studio business"

int0x80 — Sun, 24 Dec 2023 21:46:08 +0000

Very interesting and inspiring post. I am considering also to start my own indie software business, this is great information.

New comment by int0x80 in "Git Branches: Intuition and Reality"

int0x80 — Thu, 23 Nov 2023 17:57:52 +0000

One thing that is risky about git reset --hard is that any non-committed changes are lost. That has bitten me a few times.

New comment by int0x80 in "The big TDD misunderstanding (2022)"

int0x80 — Sun, 19 Nov 2023 17:16:28 +0000

Sometimes, you have to make a complex feature or fix. You can first make a prototype of the code or proof of concept that barely works. Then you can see the gap that remains to make the change production ready and the implications of your change. That involves fixing regressions in the test suite caused by your changes.

New comment by int0x80 in "Python errors as values: Comparing useful patterns from Rust and Go"

int0x80 — Thu, 09 Nov 2023 17:45:51 +0000

Exceptions are a very useful tool. In your example, the main program logic is buried in error handling which makes it more difficult to read the code and the code becomes more complex, leading to more bugs. In many cases, it's preferable to have a single error handler centralized in one place, out of line of the main logic. This makes the code more readable, reduces complexity and duplication.

New comment by int0x80 in "Nobody Understands C++: Intro (2007)"

int0x80 — Mon, 30 Oct 2023 07:33:14 +0000

I know very well what it means to care about a memory allocation cost or an atomic operation in a fast path. In some applications though, that is not the dominating performance factor, instead the algorithm dominates. For example, with C++ an manual memory management our application could take something like 58 minutes to run while in Java it would take 60 minutes. The impact of the low level management is entirely insignificant for performance in the big picture in these cases.

The performance comes from the big O complexity. Memory management is a constant factor in the algorithm.

New comment by int0x80 in "Nobody Understands C++: Intro (2007)"

int0x80 — Sun, 29 Oct 2023 17:17:43 +0000

When I mention constructors I am talking about initializer lists and all the subtleties and special cases around them.

Basically most of the complexity I mention comes from memory management. It's just a lot of details to know about and keep in your head. It's the price to pay for the flexibility and power.

In Java you need to understand references and object lifecycles or you get memory leaks and slow applications.

Actually, I work on a performance sensitive application and it's written in Java and it's a good choice for it, since the performance comes from algorithmic complexity, mostly from asymptotic complexity. A C++ rewrite wouldn't significantly impact the performance of the application.

New comment by int0x80 in "Nobody Understands C++: Intro (2007)"

int0x80 — Sun, 29 Oct 2023 12:19:44 +0000

I find today's C++ extremely challenging to pick up speed for someone coming from let's say, Java. Smart pointers, pointer/references, rvalue reference, copy/move semantics, (perfect) forwarding, constructors, and how all that interacts with templates. It's just so unwieldy complex. It takes me hours to write something that would take less than a minute in Java even though I have experience with plain C. The worst thing is that after it finally compiles I feel I can't be sure if I've followed all the rules and best practices correctly or if it's going to blow up spectacularly and potentially unsafely at runtime. The fact that a book like "Effective Modern C++" is needed with all those traps and foot guns to be aware of is ludicrous.

And don't get me wrong - I think C++ is the most powerful language out there on the right hands - it just feels to require a lifetime of learning to became productive on it.

New comment by int0x80 in "Static Analysis Tools for C"

int0x80 — Thu, 26 Oct 2023 18:33:20 +0000

If a static analyzer is sound, which is something that can be mathematically proven (formal method), will find ALL existing issues plus some false positives if it's not complete (which is almost always the case).

New comment by int0x80 in "Germany Will Force 80% of Gas Stations to Install EV Charging, Too"

int0x80 — Mon, 11 Sep 2023 19:01:50 +0000

Fuel taxes don't address the same issue. Availability of chargers is a blocker for EV adoption. The measure directly helps with that problem, while fuel taxes is a more indirect push. In other words, even if you are heavily pushed by fuel taxes, if you have a blocking barrier with charging infrastructure, buying an EV won't be feasible to begin with.

New comment by int0x80 in "A minimal operating system (2K LOC) on QEMU and a RISC-V board"

int0x80 — Thu, 18 May 2023 12:19:17 +0000

Very useful learning project. It's written in C mostly. Would be cool to do something similar in Rust.

New comment by int0x80 in "Lessons learnt while trying to modernize some C code (2022)"

int0x80 — Sun, 19 Feb 2023 19:35:13 +0000

gobject is trying to add OOP to C. C already has a type system indeed, however it can be considered weakly typed.

New comment by int0x80 in "Vramfs – GPU VRAM based file system for Linux"

int0x80 — Sun, 19 Feb 2023 10:18:13 +0000

Neat! The implementation is simple, clean and well structured -- a good way to understand in more detail how a FUSE filesystem is implemented.

New comment by int0x80 in "Git-sim: Visually simulate Git operations in your own repos"

int0x80 — Sun, 22 Jan 2023 17:01:21 +0000

Because most problems like merging and resolving correctly, or rebasing or squashing if needed don't get resolved by cloning a new repo. If you avoid learning the tool and you just clone a new repo when you have a problem you won't be able to do any non-trivial task in git.

New comment by int0x80 in "Ask HN: What is the best advice you received in 2022?"

int0x80 — Sat, 17 Dec 2022 18:22:56 +0000

I find this as being indirect and dancing around the issue. When I do e.g. a code review and I see a glaring defect on it - I point it out very clearly and directly to make sure there is no misunderstanding - I say, XYZ is incorrect. Because of blah-blah. No feelings attached to it, just a fact.

New comment by int0x80 in "Cache invalidation really is one of the hardest problems in computer science"

int0x80 — Sun, 27 Nov 2022 07:23:00 +0000

There is __attribute__((aligned)) that some compilers provide (e.g. gcc, clang) but it's non-standard.

New comment by int0x80 in "Ask HN: Working as a software engineer for 5 years, I've forgotten all CS stuff"

int0x80 — Sat, 03 Sep 2022 17:52:41 +0000

You say "be a programmer" to make it sound demeaning. I am not a "programmer" I am a software engineer, which is a very different way to put it. Studying CS to be a software eng is definitely not over kill.

New comment by int0x80 in "Programming breakthroughs we need"

int0x80 — Wed, 17 Aug 2022 22:00:21 +0000

"Principles of Program Analysis" covers the subject very well. It's not an easy or beginner book because it's very formal, but very complete and with plenty of examples.

New comment by int0x80 in "Programming breakthroughs we need"

int0x80 — Wed, 17 Aug 2022 20:49:33 +0000

The problem is what I mentioned at the end of my other comment -- complex programs will get inputs from web APIs, console, database, so it's not possible to have complete runtime coverage for all paths in the interpreter on the general case.