Newest Comments

  1.  

    Haha I see know what you meant! And indeed, that was the original reason :-) language implementation has always been my passion so I wanted to see how far I could get into implementing a language to the specification. I picked Scheme R6RS because I thought it would be easy and small (how wrong I was!)

    1.  

      Oh that’s sweet! Very cool to see syntax-case in steel!

      I hope I wasn’t missrepresenting your project! Let me be clear here: Steel is faster and more featureful than Scheme-rs by a long shot. I brought up syntax case because that’s were the initial bulk of my effort went (the remainder went to reimplementing the project as a compiled)

      1.  

        Propmpted by this exchange I have found this https://github.com/linuxdeepin/deepin-anything as a dependency of https://github.com/linuxdeepin/dde-file-manager and https://github.com/linuxdeepin/dde-grand-search

        but frankly I couldn’t understand how it works together.

        1.  

          I don’t think anyone uses the old non-WAL mode anymore!

          I wasn’t aware of wal2 … it sounds as though it’s only an advantage in very write-heavy workloads? Probably not relevant in a search engine.

          1.  

            People can build browsers that use servo, verso is one example

            1.  

              The focus on energy consumption misses the point.

              People like the OP often assume that using more energy automatically means more pollution and environmental damage, but it’s because they are thinking about coal plants.

              What really matters is how we generate that energy, not how much we use. Take countries that rely almost entirely on hydroelectric power, where turbines harness the natural force of falling water, or those powered by nuclear plants. In these cases, if we don’t use the available energy, it simply goes to waste. The energy will be generated whether we use it or not.

              So when we’re discussing the ethics of training LLM, their energy consumption it has nothing to do with being ethical or unethical. The nature of the energy sources are a different topic of conversation, regardless on how much energy they use.

              1.  

                lol. On the privacy side, Firefox now collects and sends “telemetry” by default and suggests (by default) websites/services that notoriously violate user privacy. It even defaults to using Google as the search engine (wtf!)! Firefox/Mozilla do not actually care about privacy.

                1.  

                  This is a great read. Thank you for sharing it.

                  Some stream of consciousness, running notes, as I read through:

                  “Oh, it turns out, they’re wrapping GMP.” That’s definitely not constant-time!

                  You would be surprised how often this particular finding crops up.

                  Narrator: I wouldn’t.

                  For this blog post series about Signal, I will use Semgrep, because it’s currently free as in beer (though the prominent Series D funding announcement makes me worry about its eventual enshittification, so don’t take my hasty tool selection as any sort of endorsement).

                  Semgrep looks like a free trial. So “free as in the taster of beer that the bartender will pour you so you can decide whether you want to buy a whole one”. But in any case, I don’t think charging me for a product is really enshittification.

                  Missing sections from the technical documentation are like a flashing neon sign that says “audit me”.

                  I’ve done a couple crypto audits and (many) general network security audits, and this is a fundamental truth. Both for missing sections and for present-but-suspiciously-under-detailed sections. I like to map documentation sections to the source tree, then see what parts of the source tree have missing or superficial docs.

                  Every time I learn new ways to attack cryptosystems, I always look at Signal or Tor to see if I can break either of them, because they’re difficult targets and you win instant bragging rights if you succeed.

                  This is the most time I’ve spent writing about a negative result on this blog.

                  If you read this whole series from start to finish and feel a little disappointed that nothing fell out of my review, I want to make something clear to you in particular:

                  I didn’t feel that “I looked at Signal and didn’t find any vulnerabilities in it” is exactly a convincing argument, so instead, I wanted to lead you down the journey I took to review Signal; to show you the code snippets I reviewed, and what (if anything) significant I thought about them.

                  I like the way this person thinks. I haven’t spent enough time with the Signal source code to say whether I agree with these findings. And I still don’t like that you need a phone and a phone number to bootstrap Signal. But this was a well-written and well-explained piece about why the cryptography behind Signal’s protocol is very likely as solid as we expect it to be.

                  1.  

                    Right, but there was an understanding that only good devs could make a high salary, so the money motivation worked. Today there’s the idea that there’s plenty of work LLM copyists and many people would do it for a living wage.

                    1.  

                      I see the distinction and am saying most programmers neither know nor care about Alan Kay’s definition. I may personally find it a very sensible definition by which to organize and orchestrate a complex program, but what good is it if most people hear “OOP” and think classes?

                        1.  

                          Alpine can, and does, support multiple init systems

                          1.  

                            Sure! It is a positive comment. You want to implement Scheme just because you want to implement it! There’s no “why”, like for example:

                            • So What are you doing these days?
                            • Oh, I am writing a Scheme interpreter in X
                            • Why? (Implying there are a gazillion implementations already)

                            You never ask someone “Why did you paint a rose?”. You congratulate them and ask for a bouquet next

                            1.  

                              Disclaimer: steel is my project

                              This is very exciting to see - native compilation is something I’ve been wanting to work on for steel for a long time, I’m happy to see someone else take a stab at it for their scheme. I’ve been toying around with cranelift for years but haven’t had the dedicated time to push through the work on it

                              To address two of the points on syntax-case and async:

                              As of last night, steel can define this:

                              (define-syntax (loop x)
                                (syntax-case x ()
                                  [(k e ...)
                                   (with-syntax ([break #'k])
                                     #'(call-with-current-continuation (lambda (break)
                                                                         (let f ()
                                                                           e
                                                                           ...
                                                                           (f)))))]))
                              
                              

                              Just have to work on the datum->syntax and then there is parity. The syntax-case implementation was slightly broken in the mainline for a while (and also, undocumented).

                              For async, steel does have support for rust async functions registered against the runtime, and I have a fun way of integrating with an external executor instance via continuations, but it does not have an async public api (yet) like you do. Best of luck with this and I’m excited to see where it goes

                              1.  

                                When I was learning how to code I copied code from a Basic programming manual with only a bare understanding of what was going on, or even English. “syntax” in Syntax Error, ‘function” in “Illegal Function Call” or all words in “Type Mismatch” were errors Basic would throw at me. I had no idea what these words meant; now I do. It didn’t help that I was also a kid. I wrote in my blog about this

                                The internet provided a very different new path to learning how to program not available to me until much later.

                                In this era of LLMs there are going to be new paths to learning how to program too. Are they better or worse paths? I think the jury is still thoroughly out on that one; this topic is only being explored right now. I know a lot of people have a strong opinion that it’s definitely bad but who knows what learning trajectories are being figured out by intelligent, motivated people right now?

                                1.  

                                  As a junior dev myself, I’d stand in the “LLMs are only useful in very particular conditions” crowd.

                                  • I’ve never seen an LLM understand complex concurrent systems.
                                  • I’ve tried GitHub copilot’s nvim integration for a while. Perhaps I’m using it wrong, but it feels like a glorified snippets generator. Somewhat helpful to complete tedeous things like error handling in Go, I suppose.
                                  • By far the most useful way I’ve used LLMs in programming: I’d give it a large chunk of code from multiple source files and let it identify duplicate code that I should refactor out. I’m not sure whether this is useful to others though, in particular because I have a more ad-hoc approach to functions.

                                  The core issue is still, as always, people copying code that they don’t understand. I don’t think the complaints about junior devs have changed, although by the time I started programming nobody was really actively complaining about junior devs copying blindly from SO anymore, as people seemed more or less aware that other people’s code likely doesn’t apply to your situation. But perhaps people have this illusion that using LLMs definitely generate relevant and correct code if you give it sufficient context.

                                  1.  

                                    I’m not sure what your comment is intended to say. Can you elaborate please?

                                    1.  

                                      I don’t have a great deal of experience with LLMs, but typically as soon as I ask them more than two follow-up questions, they begin hallucinating.

                                      I was recently working with go-git and decided to ask ChatGPT how I could upload packs via SSH as the documentation didn’t make it seem immediately obvioys, it kept trying to use nonexistent HTTP transport functions over SSH even though I explicitly provided the entire godoc documentation for the SSH transports and packfiles. Granted, the documentation was lacking, but all I needed to do at last was to thoroughly digest the documentation, which ChatGPT is evidently unable to do. In another scenario, it also suggested ridiculous things like “Yes, you can use sendfile() for zero-copy transfers between a pipe and a socket”.

                                      Anyhow, at least for the fields that I encounter, ChatGPT is way worse than asking on SO or just asking in an IRC channel.

                                      1.  

                                        Ah yeah, I attended one of those and it didn’t really work out at all. Hardly any discussions, everyone seemed to just do bathroom breaks between the talks (also 1 day conf, no longer breaks).

                                        I’m not saying it can’t work - I’ve just not seen it work - as a 25y IRC user, I’m certainly not shy to type.

                                        1.  

                                          Sorry for not answering your questions directly, but since you’re just starting out and expressing an interest in how things work, I would refer you to Andrej Karpathy’s YouTube channel, in particular this playlist (the first video of which is probably the single best resource for the average programmer to understand the fundamental building blocks of all deep learning).