Comments by "k98killer" (@k98killer) on "No Boilerplate" channel.

I use my old Raspberry Pi as a provate git repo host on my LAN. Among many other repos, it includes a repo in which I keep my dream journal, which is a plain text file that is formatted with the date followed by paragraphs, with each entry separated by new lines. I'm definitely a fan.
34
Technically wrong about mathematics being something purely discovered. There are provable paradoxes at the center of mathematics due to the axioms used in its construction, specifically in set theory as the foundation of all mathematics. Russell's Paradox is the most well known.
32
I think that "monotropism" is a concept you will appreciate with regard to the way our minds work when engaging a topic.
29
@JeffHanke I've recently set up a small server running Kanboard and made several, publicly viewable boards relating to important goals so that others can track my progress. Maybe this experiment will prove the technique to be useful for streamlining communication in a way that does not dodge accountability, but, at the very least, having a clear set of tasks makes it easier to stay focused in my experience.
15
I kinda want Rust's memory management in a Python interpreter. To me, that is the most compelling feature and the only major improvement that could be added to Python other than optional strict, static typing. (To simulate the latter, I use assert preconditions.)
5
I have not really liked using Rust so far with an admittedly small sample size, but I do really love the deep, detailed discussions that the Rust community tends to generate. The merging of high level functional programming and low level memory control has been enlightening to witness and learn about. I feel inspired to make my own language (well, another language -- I've already made a simple language for building embedded ACLs that compiles to bytecode and is extensible with up to an additional 194 operators) that merges some Lisp syntax with lexical scoping, more data structures than just a singly-linked list, consistent and no-nonsense naming convention, reference counted pointers for all variables, and no heap memory. The algebraic type system and idiomatic result handling are things that will probably make it into the first version.
5
I might be mistaken, but the newest Wasm standard being currently rolled out supports a garbage collection mode that does not require bundling a garbage collector. Wasm looks like it will be the new, universal platform target for compilers -- basically fulfilling what Java wanted to do. Also, the Go dev team is currently experimenting with arena allocations, which will significantly improve the control programmers have over memory management, but, even without arena allocation, it is possible to manually manage memory in Go to some extent for performance optimization -- it is tricky, but still a lot easier to get a handle on than Rust RAII imo. The greatest strengths of Go are the mild learning curve and excellent concurrency model. The greatest strengths of Rust by comparison are more consistent performance for large applications, good performance on resource-constrained/embedded systems, and the ability to tell people that you write code in Rust.
4
@NoBoilerplate it might be, but it doesn't turn my stomach sour like JavaScript. I'm unconvinced that I can use Rust to do all the things I do with Python, for example having a multiplatform contract that commits to a single piece of code by its content hash.
3
Rust does not have enough NaCl/libsodium functionality exposed in its crates for my purposes, and I do not believe it makes sense to spend the time to learn both Rust and how to extend the NaCl and libsodium crates when I have a functional alternative in which I have already written many working modules. So I'll have to pass on it for the moment as tempting as it is.
3
I recently was a groomsman in a wedding. I wore earplugs at the reception, and it was still so loud that I had to leave after dinner. I practiced violin on the balcony to de-stress until my carpool was ready to head back home, but I could still feel all the noise through my feet. At almost every such event, every neurotypical person I speak to recognizes that the loudness is excessive and says they wish they had brought earplugs, yet these events keep transpiring with loud noise and no earplugs. It doesn't make any sense.
3
sounds* like Damn phone keyboard
3
About 3 minutes into the video, and I'm already thinking about how I might make something similar using CRDTs. Probably easier to just use git under the hood for plain text files.
2
@NoBoilerplate I'll check out that video. On the code/contract commitment topic, you could commit to the source code with Rust, but then you would have to recompile before running every single time to ensure you are running the code in the commitment. Of course, there is an implicit security assumption with implementing this in Python that the interpreters will be compatible, so it isn't that different. The secure distribution of software is still technically unsolved. I suppose that the largest issue preventing my use of Rust is that I haven't been using it, so I lack the confidence to build things with it. Do you have any resources for Rust TDD that you would recommend to a Rust noob? Edit for side note: I wish Python had an immutable/frozen dict type. It really does not make sense that it does not.
2
Bold move quitting your job at the beginning of a recession. Hope it works out.
2
@NoBoilerplate it takes a bit of experimentation to understand how to use any concurrency system correctly. You wouldn't ship untested code, so I don't see this lack of hand-holding by the Go compiler to be a deal breaker.
2
@NoBoilerplate true enough
2
Fact check: cats do come when you call them; they all come no matter which is called.
2
@NoBoilerplate looks like that first one might work. I'll look into it more closely when I get back to my desk. (Spent the night in the woods somewhat accidentally.)
2
Imo, the reality of Rust is far less attractive than the idealized promise of Rust. Is it cool that you can do metaprogramming with macros? Yes. Is it a great time having to learn a second language to write a macro and then wait 20 minutes to see if the compiler is happy with it? Not so much. The core design principle of Rust can be summed up with the following dialogue: "How much complexity do you want in the language?" "Yes."
2
Rust has a lot of nice features, but as a Python dev/artist, I find Rust code to be as ugly as c/c++. It seems unlikely to me that coding in Rust would be as pleasant as coding in Python. My Python code is often described by those who read it as beautiful, and that aesthetic appeal is part of what makes writing Python an enjoyable and fulfilling experience. Are there any examples you care to share of what you consider to be beautiful Rust code? If I can be convinced that it is possible to build beautiful Rust code, then I might be convinced to spend the time necessary to learn how to do so.
2
@NoBoilerplate I'll check out that video. I write primarily typed Python, use pre-conditions and sometimes post-conditions, and use a test- and specification-driven development cycle, so I don't worry much about things being broken. And like I said, the idea of my code being clean and beautiful is reinforced by feedback I have gotten from others who have perused it, so the assertion that nobody will agree with my definition of beauty in this case is false. Maybe there is an argument to be made that Rust development saves time on writing pre- and post-conditions, but whether that offsets the time commitment to learning a new language when I'm already proficient in the three or four that I regularly use is an open question. I can appreciate that there is beauty in that Rust example, at least conceptually, but I wouldn't call it "objectively beautiful" since there is no such thing. Whether or not it is aesthetically appealing also depends upon the surrounding code in my opinion -- part of what makes my code clean is that I use standardized forms that are easy on the eyes (pep8 with my own subjective flare). The ".collect::<Vec<i32>>();" to my eyes does not look particularly clean and beautiful -- it looks like someone copied and pasted html and JavaScript in a confused and haphazard way, but that could be my web dev background coloring my perspective. I also found Java code distasteful for the same reason. Angle brackets are just ugly unless padded with whitespace, and they only make sense as comparison operators in that case.
2
Fwiw I prefer the phrase "experience is the best teacher" over "fake it till you make it". Same principle, just less scandalous formulation that does not leave room for the inference that deception is condoned or advised. I'm sure most people have a story or two of someone getting burned in this industry because someone else misrepresented their abilities, and "fake it till you make it" like like it condones such behavior.
2
Hard agree on Markdown. I even wrote and published a tool called autodox that automagically documents Python modules via introspection, and it outputs exclusively Markdown. (It also has some formatting options, but I don't use them -- the default formatting is pretty good imo.)
2
@NoBoilerplate except that plain text does not have good merge semantics, hence the necessity of manually resolving merge conflicts in git. Google Docs and Figma use CRDTs for collaborative editing of shared state, but my main concern is supporting offline app use by ensuring strong eventual consistency (i.e. after all nodes synchronize all updates, each node will arrive at the same state no matter the order of update application, number of times an update is applied, or any finite delays introduced; as long as all nodes eventually get all updates, they will converge to identical state). It would be fairly easy to output plain text after assembling the data view from the underlying CRDT(s), but plain text itself is not viable for strong eventual consistency.
1
@NoBoilerplate I am currently working on a CRDT library in Python that I'll publish once I'm sure my test suite is complete (10 different CRDTs implemented) and then spend some time reviewing/manually experimenting with it. Maybe I'll eventually port it to Go. If and when I make a note taking app with it, the whole thing will be FOSS. The structure of Markdown should be pretty easy to translate to and from a composition of CRDTs (e.g. each header could be a last-writer-wins register; each paragraph could be a causal tree; each list could be a Fractionally-Indexed array; etc), so portability hopefully won't be an issue.
1
Yo dog, we all know that Rust devs don't just chill. They gotta make sure everyone around them knows that they are writing code in the correct language and then cancel someone for smelling like they are politically slightly to the right of Stalin.
1
I don't blame them. Gotta find something to do while waiting for the compiler.
1
@TypicalHog wanna hear something that will make your head explode from cringe? I made a domain specific language and byte code VM that runs in Python. The compiler has a system of macros and comptime features that work inside of macros. There's an op that evaluates a Merkle tree proof of a script and then executes that script. There's also an op that does the Taproot mechanism of checking that a public key and script commitment combine into the taproot key then execute that committed script or validating a signature against the taproot key. It doesn't even have proper variables, so instead I added syntax for quickly accessing the cache, which is actually a Python dict mapping byte names to lists of bytes. The compiler/assembler does not use an explicit AST and instead just uses basic arithmetic to calculate offsets when compiling blocks.
1
@NoBoilerplate conversely, the risk of working a job you don't have is 0%. Sometimes that's a risk worth taking. (Don't mind me. There's a reason it's called "Saturday" and not "Soberday".)
1
@NoBoilerplate I will admit that I liked Common Lisp less than Rust, so if I was going to build a new syntax using macros, I'd rather do it in Rust than in CLisp. However, I am inclined to write the reference implementation in Go because I feel confident in my ability to write performant Go code and because I'd rather start from scratch.
1
"Don't worry, they're coming. The [features] are on their way." -- South Park's George R. R. Martin
1
Vim is my word processor of choice right now. Edit: I wrote this before getting to the part of the video in which vim-mode was suggested
1
I just came across an article about using vim as the best word processor. It was funny that it had as many spelling errors as it did -- that is one thing I have struggled with in using vim as a word processor as well.
1
@NoBoilerplate I went through the syntax of Haskell many years ago, but never made a point to do any real development with it. To be honest, I don't enjoy developing web applications anymore -- it's just something I do because it fulfills an economic niche, so I just stick to Laravel because it is the best web application framework I've used. I did some DevOps and database admin work, but those were also really tedious and unenjoyable. My real passion is writing distributed applications and cryptography stuff, and it's always a bonus if I can find a real use case for machine learning (e.g. for creating a greedy embedding using latency data for a wireless network, which I have experimented with but not yet published on arxiv). The fact that it is relatively easy to write beautiful Python code that reliably does all the things I want it to do is a real advantage -- it is really easy to get demotivated/discouraged when working with all other languages I have used in the past because of how it almost invariably ends up being a disgusting, jumbled mess. I'll give Rust a chance when I get one, though it is likely that I'll just continue working with Python since I have already written so much in it and am getting close to being able to write my magnum opus.
1
JavaScript is undeniably an awful language. Python doesn't have to be, though some ways of using it are awful. The bit about the helpful error messages from the compiler is definitely quite an attractive feature, especially for someone learning the language -- I remember being very frustrated when learning Java, C/C++, and JavaScript due to the error messages often being dense and unhelpful, and that kind of experience is probably part of what holds back developers from learning new languages. I'll give Rust a chance when I get one.
1
@NoBoilerplate The GIL is definitely an issue for concurrency/multithreading, but performance is slowly increasing, and there are options for gaining additional performance with PyPy, Cython, Numba, lru caching decorators, etc. It's more work and detracts from the allure of pure Python, but if performance is a big issue, then better performance can be achieved with a bit of additional effort. Just as a random thought, I wonder if a new Python interpreter/JIT could be made with Rust that makes use of Rust's memory management. Would it be compatible with CPython? Would it have improved performance? Could it do away with the GIL? And if the answer to all those is "yes", would you be less disillusioned with it? Edit: what are your thoughts on the multiprocessing library?
1
The only useful AI tool I have encountered that has come from this LLM hype bubble is Cursor, specifically when refactoring or continuing with some clearly laid-out pattern. Everything else is pretty terrible.
1