Threads for yonkeltron

  1.  

    A colleague and I used Semgrep to conduct some static analysis research, so this is really interesting to see. I do wonder if it’s ever going to be opened up as FOSS given its broad application.

    1.  

      I adore the macrocentric approach to adding even basic syntax. What would a stdlib even look like in terms of both functionality and syntax?

      1.  

        Thanks for the kind words! The standard library would define three foundational modules:

        • kernel, which contains all possible system level effects (I/O, etc.) that must be handled by the host runtime
        • compiler, which defines Passerine compiler types (e.g. AST) that are used by the macro system.
        • core, which implements the core language (if, for, match, etc.) in terms of foundational language primitives, like tail-recursive functions and lazy && evaluation.

        These modules are all part of the prelude, and included in other standard library modules, which are written in relatively-normal Passerine. Actually writing out and binding these libraries to the compiler pipeline is something we’re working on right now.

        1.  

          Thanks for such a killer answer. Really impressed by what you’ve put together here and looking forward to learning even more as things progress.

      1. 8

        I just kind of love that Zoom uses XMPP, which I had no idea about. Big fan of XMPP as an unsung hero of the messaging realm.

        1. 5

          Without federation it’s as heartwarming as knowing that Apple’s App Store interface is a WebView.

          1. 1

            Did they switch to HTML? People always claimed that the itunes store was HTML but it was a custom format with a custom renderer.

          2. 3

            Facebook Messenger also uses it internally, or at least it did at some point. Now if only all the XMPP users actually federated…

            1. 1

              It did, but it’s all MQTT these days

          1. 2

            While this is intended for web content (it’s a collaboration between Google, Microsoft, and Yandex), it’s interesting as a general data-modeling project, too.

            1. 8

              Each day we stray further from Codd’s light.

              1. 2

                These seem like higher-level descriptions. I don’t see any reason you can’t use them in a relational DB after some straightforward normalization.

              2. 1

                Somewhere, William Kent clenches his fist.

              1. 5

                Was worth reading this just to be able to learn about IRCv3 which seems so cool!

                1. 3

                  Some previous discussion on HN: https://news.ycombinator.com/item?id=30218954

                  It’s not clear to me what advantages, if any, this encoding has over the current semi-standard of Protocol Buffers (+ clones such as Thrift).

                  1. 1

                    I am also unsure where this fits in with other security-focused formats such as Saltpack and more general efforts at future-proofing attempts such as Multiformats.

                    1. 1

                      Likewise, it was not clear to me why this would be more secure than pretty much any other format. There’s a bit of a disconnect between the goals and the result.

                      1. 3

                        It’s pretty strict about formats and representable values, and specifies a bunch of types not natively represented in JSON, so it’d be less prone to issues caused by ambiguous parsing/validation, which has been the cause of some major security holes.

                        But while I like the approach, especially having both a binary and text encoding, I think it tries to do too much. My enthusiasm waned the further I read down the spec. I get the feeling it will be quite a bit of work to implement, which weighs against its getting much use. Part of the appeal of JSON, outside JavaScript, is that it’s really easy to write a codec.

                        1. 2

                          When I got to the part about graphs and trees, that felt like a really bad scope creep.

                  1. 3

                    Love to see companies not only funding research, but doing so publicly with the intent of bettering an entire ecosystem! Sets a good example for folks about the value of learning and exploration of various types. What other companies regularly engage in such activities?

                    1. 12

                      This is an article completely without merit.

                      1. 2

                        (let’s try to be a bit better than one-line unsubstantiated dismissals)

                        Issues I had with the article:

                        A broad layman’s definition of a psychosis is roughly; “The belief in something that has been proven to be wrong”.

                        This is, at best, an extremely poor definition of psychosis with little explanatory power–for example, it would seem incorrect to lump everyone who believes in Santa or the Easter Bunny as being psychotic. The author presumably did this to segue into the idea of mass psychosis (the neat little history lesson about dancing and laughing diseases), but it would seem to me there’s rather a distinction between mass psychosis and merely a rigid, questionable orthodoxy; after all, there aren’t exactly programmers complaining to their mental health caretakers “Doc, I just..I just can’t stop adding inheritance! I tried, maybe just one more member function and I can give it up for good! It just seems so sad without an extra interface!”. There is no ICD-10 code for compulsive enterprise architecture.

                        For 30+ years, software developers have been taught a mantra that over time has turned into more or less the declaration of faith required to believe in to be able to land a job as a software developer, and this mantra is as follows.

                        This is, to my reading, a pair of unsubstantiated claims:

                        1. For 30+ years (so, since before 1992), software developers have been indoctrinated into OOP.
                        2. This orthodoxy is required to land a job.

                        Had I written this screed, I would’ve gone back and grabbed job listings, maybe a bunch of old Java agitprop from 90s Sun, some old developer marketing from NeXT Computer, and topped it off with the AP CS exam’s marine biology case study or whatever damn fool thing they’re pushing on students these days. The author does not do this, and anybody with a cursory knowledge of history (or just a suspicious mind) can and should assume there’s more to the story there–unless their most recent job interview specifically grilled them on OOP stuff.

                        When in fact 30+ years of history has taught us the exact opposite. For instance …

                        Hindsight is 20/20, as the saying goes, and nothing is more tiresome–to me anyways–than prosecuting the past for not knowing the crimes of the future. The bigger failure here by the author is that they present such a one-sided polemic against the “failures” of OOP that they leave nothing for those of us who have seen similar or worse failures in functional programming. Excerpts from their list:

                        • “…necessary complexity and virtually impossible to understand code…” can be true, but there are similarly bits of Haskell or Lisp that will make your eyes bleed.
                        • “Polymorphism results in chaos and extremely hard to track down bugs” can be true, but any language with pattern-matching (hi Elixir and Erlang!) in function heads lets you do polymorphism and run into the same set of problems. It’s even worse since many functional programming languages really prefer to be dynamically typed and interpreted. This is not a failing solely of OOP.
                        • “entangles your logic and data in ways that are arguably the very definition of madness” is again true, but using logic (functions) as data is kind of the hallmark of functional programming, and so again I assert this issue persists outside of OOP.
                        • “Single responsibility results in 1,000+ classes for something that could have been done with 5 functions in FP.” is sometimes true, but I’ve also seen OOP codebases where everything really is baked into a nifty one-liner. A trend (pulled in from Rubyists in my experience) of decomposing every function into lots of teeny helper functions is just as bad in functional languages.

                        If OOP was a solution to anything really, we wouldn’t need design patterns, clean architecture, or SOLID design principles.

                        “If being alive was enough for us, we wouldn’t need crutches like livers, lungs, brains, or philosophy.”

                        This is one of those sections of such low rhetorical quality I’m tempted to agree with @hwayne’s simple dismissal, but just to make sure nobody buys what the author is attempting to sell: within the paradigm of OOP the tools of clean code (a nebulous idea probably referring to Uncle Bob’s book/teachings, but that’s too vague for me), design patterns (a bestiary of observed techniques in the OOP mines similar to the architectural bestiary A Pattern Language that inspired it, and emphatically not a tome of “You must write OOP this way!”), and SOLID design (a set of observed “hey, if you do this it should prevent certain types of issues”) are there as guidelines and not mandates.

                        There is a large difference between OOP (either Kay-style message passing entities or vulgar Java-style inheritance and interface object farms) and the techniques observed and suggested for achieving it. Making the same error as the author, I might claim that if functional programming was all we needed why waste time with monads and currying and functors and type systems and promises.

                        19 of the 23 original design patterns from GoF’s book made absolutely no sense what so ever in LISP.

                        Well, yes, the gang of four weren’t surveying Lisp codebases, so this shocking result perhaps isn’t so shocking.

                        I’ll also point out that CLOS totally allows for, and in some cases benefits from, those same design patterns the author complains are bunk.

                        ~

                        I’ll stop at this point on the article, because I think I’ve hopefully made the point that the rhetoric just isn’t very good.

                        I do want to make two minor requests to folks here though, if you find yourself dismissing or even worse writing one of these submissions:

                        • Please don’t just dismiss them out of hand. It can be extremely helpful to others to see why something is poorly constructed, and too much out-of-hand dismissal weakens the utility of our community and also sets unfortunate norms around lazy thinking. Sure, today, the dismissal is careful and correct, but at some point we stop having brief-but-considered dismissals and instead get lazy-and-unconsidered ones–and it’s almost impossible to tell when that tipping point occurs!
                        • If you have to write one of these things, please define the stuff you’re arguing about and please attempt to address the objections of folks who don’t already agree with you. It’ll help you make better, strong, and longer-lasting arguments, and it will give the rest of us something to grow from whether or not you end up being correct.
                        1. 7

                          (let’s try to be a bit better than one-line unsubstantiated dismissals)

                          The article is called “OOP a software development mass psychosis”

                          1. 0

                            Pointing at something and going “this is cringe” is cringe.

                            If your assertion is “this title is clickbait and thus beneath review”, I present counterexamples:

                            Please don’t encourage intellectual laziness on this site.

                            1. 3

                              Okay, let me justify why I think a one-line dismissal is valid in this case.

                              My problem isn’t the clickbait. I’m probably the biggest fan of clickbait on this site. “I ****ing hate science”? I wrote that. All my good titles are clickbait. And my problem isn’t cringe. I originally defended NeoVim is Shit and Ruining New Developers, because I thought it was someone’s personal diary and publicly making fun of that is gross.

                              So when I clicked the article, I was willing to give it the benefit of the doubt. And then it very, very quickly squandered that benefit of that doubt. It’s contemptuous, condescending, low quality, incoherent. I feel worse off for having read it.

                              It’s not about “intellectual laziness”. It degrades the site if we’re intellectually lazy. It also degrades the site if people keep posting low-quality articles and we waste time dunking on them. This article is so beneath our standard of quality on this site that it doesn’t deserve attention. I wanted to make clear it’s not worth engaging with in the first place, so we can spend our time on more interesting things. It’s without merit.

                              1. 0

                                I wanted to make clear it’s not worth engaging with in the first place

                                Okay, but setting the precedent for “If something has the hwayne (or angersock, or pushcx, or whoever) dismissal, you can safely downvote it and ignore it” is nothing but enshrining an appeal to authority. Telling our folks “hey, if friendlysock flags something as garbage without explanation, you should just go along with it” is not good. I’d argue it’s a lot worse than even the modest burden of writing a couple of points of rebuttal or critique.

                                In three sentences (no reason to dig in as far as I did, and I left a lot on the table) you could’ve substantiated that it was a low-quality article.

                                Something we’ve seen time and time again in the last many years, in politics and other places, is the failure of the self-proclaimed expert and the erosion of trust in institutions. Most of that stems from approaches like you’re advocating here: all well and good until one day someone tallies up the dismissals and realizes hey, guess what, there really was something useful in there, what if all of these aren’t bunk?

                                Better to show your work.

                        2. 1

                          I’m not saying I agree with it, only that it was worth posting.

                        1. 3

                          Looking at this across 40 years… It’s obvious that you must and at all costs separate your models and your views to build quality software. This is fundamental, and to fail to do so is to be completely, utterly, and hopelessly, lost.

                          All that mucky stuff in between though …

                          1. 1

                            Adele Goldberg’s blue book is a fantastic testament to this lesson being clear from the get go.

                            1. 2

                              This is quite a large book and I have only spent some time with it…. but I suspect you and I might have differing ideas about clarity.

                              After an hour, I’m having a difficult time pointing to any piece of this which would really help the discussion, though I suspect that anyone who was confused about MVC might benefit from a few weeks or months of careful study of this text.

                              Let me get back to you with my thoughts on this, it may be several years.

                          1. 1

                            Is gotty unmaintained as you link to it?

                            1. 3

                              Yes it is. I’ve done some maintenance recently on my fork to update xterm.js and enable we go rendering.

                              Http://GitHub.com/ghthor/gotty

                              1. 1

                                Amazing! Thanks!

                                1. 1

                                  it appears as though this fork is being maintained. Trying it, but it doesn’t pick up my font & color preferences. Probably due to xterm.js

                                  https://github.com/sorenisanerd/gotty

                                  1. 1

                                    I reviewed that fork and wasn’t impressed with the quality of the new code.

                              1. 3

                                There are some interesting historical details in here but I have always thought and continue to think that MVC is a solution in search of a problem :)

                                Models and views have always seemed very clear cut to me, but IMO the controller is where we often run into trouble. It seems to invite framework / library designers to shoehorn various disparate ideas into this sometimes ill fitting abstraction, and as a result you can end up with some very cumbersome tools like J2EE.

                                1. 3

                                  The controller described in the original version of MVC is not something that users of GUI toolkits use today. It is handled by the windowing system. The more useful vestige that I generally refer to as a controller is parameterizing widgets like buttons or tables so you control their specific behavior (onClick, getLabel, isActive for a button, for example) by providing them with an object that implements those methods. This is how Cocoa uses it.

                                  You’re right about people trying to shoehorn things into MVC without understanding the constraints its solving for. I think that those constraints are:

                                  1. The views on the data must be able to operate and update completely independent of one another, so you need a choke point (the model) where there is an authoritative form of the data and views update based on that.
                                  2. You want to be able to reuse views so that you have a consistent UI language, so you set up that visual language and let people wire up the semantics of the language in a specific case.
                                  1. 1

                                    The Newton folks observed that the purpose of the controller is to avoid creating a specialised view for each model that it’s attached to. They then proposed that this is necessary only in environments where creating a specialised view is difficult. Their hypothesis was that class-based OO was a good fit for models (where you have many instances of the same class for different objects) but prototype-based OO was a better fit for UIs, where you want to adapt a generic view to your specific use.

                                    Given how well JavaScript has done as a UI language, I’m inclined to believe that their hypothesis has some merit.

                                    1. 1

                                      I’m inclined to agree as well. I have tended to pass in controller objects because I wanted to keep techniques to hand that worked in multiple languages, but prototypes are certainly an easier way. You can also do basically the same thing with anonymous subclasses in Java.

                                    2. 1

                                      That makes a LOT of sense. Thanks.

                                      Are there any frameworks or toolkits, either now or historically, that implemented this understanding of MVC?

                                      1. 2

                                        Most of them. Swing, Gtk+, Win32/MFC… The model/observer stuff isn’t really the GUI toolkit’s problem. It’s a way of organizing code. And they all have a way of specifying behavior of a widget for a particular case.

                                    3. 2

                                      MVC is a solution in search of a problem :)

                                      This is one way to look at it and your specific objections are clearly valid. I would also posit that another way to look at it is the MVC pattern is a natural outgrowth of separation of concerns albeit with ill-fitting demarcations. So, in Rails for example, you will often get a different flavor of the problem you outline with “skinny controllers and fat models”. I’ve seen this (and been responsible for) where the model object gets overloaded with responsibility and grows entirely out of control. In these cases, I find that MVC is usually the start of decent design but certainly not the end of it.

                                      1. 3

                                        To be fair, the MVC being described is local GUI interfaces, not the variation of it used by web frameworks.

                                        1. 1

                                          A very fair call-out!

                                        2. 1

                                          That’s a really excellent point. If I’m honest my opinions here are absolutely influenced by the fact that I have encountered way more ungainly MVC implementations than elegant ones, and perhaps I just need to be looking at or building the right kind of code-base to have a better experience with this pattern.

                                      1. 7

                                        I’ve followed this space for awhile mostly due to professional reasons rather than personal ones. This article really resonates with me because I find Fastify to be a better Koa, which is basically the spiritual successor to Express and friends. My only complaints are around TypeScript support in the documentation and better explanations of what’s going on behind the scenes when you use async and await for endpoints.

                                        1. 5

                                          Actual article on the subject this HackADay links to.

                                          1. 2

                                            Thanks for this!

                                          1. 4

                                            This is such a good piece. I would add the negative shibboleth of “trust is upstream” because I hear that pretty often right before an overly trusting component fails.

                                            1. 2
                                              1. 1

                                                Great question, it def could! I was referring more to buggy peers (clients, servers, etc.) sending either bad messages or messages badly. Your point is exceptional, however.

                                            1. 2

                                              I had used Twine before and it’s ridiculously cool. This seems just as cool but in a different way. Excited to dive in.

                                              1. 5

                                                It took me a while to find it, but the TAP 14 spec was released on April 18, 2022. I haven’t used TAP in a few years, but I’m glad to see it’s not dead.

                                                1. 1

                                                  Agreed. As the implementor of a Rust TAP library, this is a fantastic development.

                                                1. 16

                                                  The reason I posted this was because of past comment threads indicating that Earthly’s choice of a source-available license may have detracted from its adoption.

                                                  1. 17

                                                    Thanks for submitting this. I work at Earthly and your feedback was influential in this decision. So thanks for pushing on this issue in a friendly way.

                                                    1. 1

                                                      Hey it is literally good for everyone for the reasons articulated in the blog post, legit. I am personally and professionally impressed that you were able to take feedback like this so seriously. Takes a lot. Would love to talk more!

                                                      Out of curiosity, will the homebrew-core formula for Earthly be updated to allow for easier installation?

                                                      1. 1

                                                        Thanks! Yes, I think we should be able to update the homebrew formula now.

                                                        1. 1

                                                          Here is the ticket tracking it: https://github.com/earthly/earthly/issues/1866

                                                  1. 5

                                                    Hi all, I’m one of the authors of the blog post / open-source Python package. cleanlab started out as a grad student research project. As we saw data scientists finding the tool useful for real-world applications, and as we did more research that applied the tool to find issues in academic datasets at scale (Lobsters submission), we realized that this was an important real-world problem and decided to spend more time and energy building a framework for solving data-quality challenges.

                                                    We’d love to hear any ideas or feedback from the Lobsters community, especially from those doing data science or machine learning. We (me, @curtisnorthcutt, and @jonasm), who all have a background in ML research, would also be happy to answer any questions you have related to cleanlab or data-centric AI.

                                                    1. 2

                                                      I might be able to Google a bit to better ask this, so forgive me if I’ve been remiss. I have noticed what seems like a rise in “distributed ML” frameworks and libraries. Obviously there’s whatever comes with Apache Spark but I know there are some other projects out there (Dask) that people seem to talk about.

                                                      1. Is this a genuine trend or new phase of evolution for applied ML? Just a curiosity?
                                                      2. How does this impact data set management and/or intersect with distributed databases?

                                                      Thanks, +Jonathan

                                                      1. 3

                                                        Distributed ML is an active area of work, in both academia and industry, and it has been for some time now. Companies like Google were doing distributed machine learning decades ago. For some use cases, libraries like scikit-learn are totally adequate, while for other use cases, e.g. when using sophisticated models that require a lot of compute to train, training over large datasets that don’t fit on a single node, distributed computing is essential.

                                                        On the topic of data storage: in some cases, system builders do co-design the data storage and data processing, e.g. data processing using Hadoop over data stored in HDFS. Such co-design can give performance gains.

                                                        Relatedly, there is a growing movement that says that there may be better solutions than throwing more data and compute at the problem, and that “data-centric” approaches to ML (like cleanlab) might actually reduce the need for some of these complex distributed systems solutions to scaling ML in many situations: better data over big data.

                                                    1. 6

                                                      I love the simple explanation of a WAL. Might be the best part of the article, imho.

                                                      1. 2

                                                        happy you liked it, indeed the article was written more to explain concepts like that using simple components rather than, idk, meeting the demand of shell-based message queues (lmao)

                                                      1. 1

                                                        I want to read this article because of the extensive Twitter discourse around hand-hacked vs. generated parsers.