1. 12
    • Job interviews continue. Kissed a few frogs in the last two months, but currently chatting with three I could definitely see working at.
    • Lobsters has been getting a lot of pull requests the last couple weeks, so hopefully I’ll be merging all the active ones this week. Really thrilled to see so many contributors that they entirely take up the Code + Coffee time I put to Lobsters.
    • Last week I finished coding the rails app for the podcast I’m starting (1100 lines of code + tests, not big). Plan is to have conversations with folks doing interesting in computing, especially at the intersection of practice and theory, then editing to 10-15m episodes. Sorta Fresh Air crossed with Planet Money but topically more like Why Are Computers? This week I’m sending out some initial interview requests and deploying the site. Going to take a run at guix for that, we’ll see how it goes.
    • An old friend is in from out of town, so plenty of catching up and board games.
    1.  

      I like the idea of the podcast. I was messing with some ideas about a podcast like that a little while ago. If you’re interested in any help with it, I’m willing to do what I can. (I think the intersection of practice and theory is the most interesting place for research and had I stayed in academia, I would be working in that space.)

    1. 2

      @pushcx , this is a duplicate of https://lobste.rs/s/5wp65s/protobuffers_are_wrong , I missed it when posted this one. Could you please merge it?

      (sorry for the duplicate…)

      1. 2

        1. 1

          Not sure if it was intentional or if something else happened but the merged story has less upvotes than the unmerged one did.

          1. 3

            The count left of the headline is always votes on the original story, but the ranking (“hotness”) of the merged story and its comments are taken into effect by Story#calculated_hotness.

            1. 1

              oh neat

      1. 1

        This talk may be in part a response to community issues raised most prominently in this story, though Czaplicki’s Strange Loop talk proposal was probably accepted long before it appeared - in April/May, on the usual SL schedule.

        1. 4

          Great to see that data get used. One question I had after skimming the paper: how much of this performance improvement do you attribute to Noria’s data-flow computation? One of the frustrations comparing these things is that MySQL has a lot of features that Noria presumably doesn’t, makes it sort of apples-and-oranges. But I really like this model of incremental computation, I see it as a larger popular trend in programming tools.

          1. 3

            Hmm, I’m not entirely sure I understand the question, but I think maybe there’s a misunderstanding about how the system works. Most of the performance improvement in Noria is due to the fact that basically all SELECTs are now direct cache hits. The data-flow is just the way that we ensure that the results for those SELECT queries remain updated as the underlying data changes (e.g., as new votes are added). This design basically decouples the performance of reads and writes: reads are always fast, and the write throughput is determined by how many things the write touches; we’re nowhere near the limit of how many reads per second we could do for the lobsters queries (see the vote results). As queries get more complicated (and again, we can support all the queries in the lobsters source code), reads do not get any slower, only writes do. It is true that now the writes are slower, but they are also rarer. In the Lobsters workload at the moment, the biggest bottleneck is the write path for updates to read_ribbons, and that’s what’s preventing us from scaling beyond 5x MySQL. Sharding that write path may be the way to resolve that issue down the line.

            As for feature parity, I don’t know exactly what you’re referencing? Is there a particular feature you’re worried about Noria not having that you rely on for MySQL? Not sure if it came across in the paper, but you can take unmodified applications that just use mysql client libraries and just plug’n’play them with Noria. At least that’s the idea modulo our SQL parser and query planner still not being quite as mature as MySQL’s.

            1. 4

              So Noria maintains materialized views, sort of like flexviews but with automatic refreshing or like pipelinedb but base data is permanent (table) rather than ephemeral (stream). Also reminds me somewhat of ksql. And since it is the database, the application doesn’t need to handle complicated and error-prone cache invalidation (e.g. in the typical MySQL + memcache scenario). Pretty neat!

              I had the same question about apples-to-oranges comparison though. For example, transaction support, foreign keys, different index types, triggers, rocksdb vs innodb implications.

              1. 3

                Yup, you are totally right that there are features of more traditional databases that we do not yet support. This is still a research prototype, so it’s focused on the research problems first and foremost. We don’t believe any of those additional features to be fundamentally impossible in the Noria paradigm though — for example, we’re designing a scheme for adding transactions, and we believe we can do it without adding much overhead to query execution in the common case!

                Some of these other features are also really optimization details. For instance, since Noria knows the application’s queries, it could automatically choose indexes that fit the query load (even though currently it only uses hash indexes). Similarly, RocksDB vs InnoDB shouldn’t matter to the application. We use RocksDB only for storing the base table data, not for storing anything else, so it’s mostly just there for persistence, and rarely affects performance.

                As for foreign keys and triggers, those should be pretty easy to add, and mostly just need engineering, not research. In a sense, triggers are really just additional operators in the graph, so they’re almost a non-feature in Noria.

                1. 3

                  You may also find the discussion on Reddit interesting.

                2. 2

                  My question isn’t about how the system works, it’s about the breadth of MySQL, which pays a performance cost for lots of features I presume Noria doesn’t have. Multi-master setups, sharding, charset collations, many more data types, support for at least five operating systems, date and time functions, multiple storage formats, a million things. Even if Lobsters doesn’t use them, some of those are going to result in conditionals on the hot path to serving even very simple, performant queries like select * from users where id = 123 and account for some of the performance difference. I say it’s sort of an apples-and-oranges comparison because Noria and MySQL have such different featuresets - if it were possible to compile a version of MySQL that dropped support for every feature Lobsters doesn’t use, I wonder if that wouldn’t be in the neighborhood of 5x faster. I have so little intuition for it I wouldn’t be surprised at 1.01x or 20x.

                  Edit: ah, and after I hit post I reloaded the page to see @tobym made this point and you already responded to it. I’ll check out the reddit link. :)

                  1. 3

                    In addition to my response to @tobym, let me try to address some of your specific concerns too. First, Noria already supports multi-machine distribution and sharding, and replication is already nearly done. Noria is also more flexible than MySQL in its data types, since it doesn’t have strict column typing. If we did apply the same schema strictness as MySQL, that would improve our performance, since we could specialize data-structures to known types. While it is true that we don’t support as many data types as MySQL, adding news ones is pretty straightforward, and we already support quite a few. Similarly, adding date and time functions should be straightforward – they are just new projection and filter operations. Noria should also run without modifications on Linux, macOS, and Windows.

                    As for multiple storage formats, Noria is, in a sense, arguing that you as the developer shouldn’t have to think about that. You should tell the database what your queries are, and it should determine how best to persist and cache the data and the query results. Are there particular features associated with the storage systems that you had in mind?

                    You are right though that MySQL does more than Noria does, and that that adds overheads that Noria does not have in some cases. However, most of Noria’s performance advantage comes from the model — computing on write instead of read — as opposed to implementation. MySQL fundamentally has to compute things on reads, whereas Noria does not, and with most operations being reads, that translates to speed-ups that MySQL cannot recover. It would be great to disable lots of MySQL features, but it is unlikely to change the picture much due to this fundamental design difference.

                    The one exception to this is transactions: it could be that transactions are just so expensive to provide, that the MySQL was is just way faster than anything you could achieve in the Noria paradigm. We don’t believe this to be the case though, as we already have a design sketch that adds transactions and strongly consistent reads to Noria while introducing nearly no overhead in the common case.

                1. 3
                  1. 3

                    The fact that both GCHQ in the UK as well as DHS in the USA speak out on this issue probably only serves to increase the suspicion that something underhanded is going on. It does raise questions about who is - or are - behind any possible shenanigans. Now all we need is some Barbra Streisand as background music and the picture is complete…

                    1. 1

                      Yeah… The GCHQ & DHS shouldn’t have any special information about this, unless they’re involved.

                  1. 3

                    Followup post is pretty good, too.

                    1. 9

                      I have been a mac user since the beige-toasters. There is no chance I would buy a computer with “DRM” crap preventing me from repairing it.

                      1. 2

                        Didn’t the beige toasters require an Apple-licensed tool to open or was that an urban legend spread in the besieged Amiga community?

                        1. 5

                          It’s correct, they used Torx screws for the case: teardown.

                          1. 3

                            I just bought a torx screwdriver from Lowe’s last week. I’d hardly consider that to be locking users out of their hardware.

                            1. 3

                              They were hard to come by in 1984.

                              1. 3

                                Yet infinitely easier to bypass than software DRM.

                                1. 2

                                  I started repairing Macs in 89 and had several torx screwdrivers so by then, they were easy to get.

                                  1. 1

                                    Good point.

                                2. 3

                                  Tri-Point and Pentalobe are two common currently examples of this.

                                  In highschool/college I worked at an authorized repair shop for Apple. Torx are great honestly. They are easier to work with and less likely to strip than Philips. Tripoint & Pentalobe are a nightmare to work with, which is why they are often not used internally.

                                  1. 3

                                    Torx is just a better type of allen bolt

                                    1. 3

                                      Indeed, there’s valid reasons to use Torx.

                              1. 2

                                wasm is now a tag and I’ve backfilled the last 30 days or so of stories.

                                1. 7

                                  As far as I know You Need a Budget (often referred to as YNAB) doesn’t track you. It’s a paid app, but it’s very worth it in my opinion. It really helped me save money.

                                  1. 1

                                    I use YNAB4 (via WINE), which was the last desktop version available for sale. It pings their server for updates it will attempt to install, but it doesn’t send budget data; synchronization with the mobile app (which I never used but think is still available) is done via Dropbox. The current version is a saas so they’ll have all your data and they offer account syncing (Plaid or a similar service) if you want to cut down data entry.

                                    1. 5

                                      +1. Everyone else seems to love GnuCash.

                                      1. 4

                                        I recently switched from GnuCash, which did work but felt unpolished and unreliable in edge cases, to Beancount, and why did I not do that sooner. I feel at home in my editor with autocomplete, regex search, bean-check for linting, bean-format for formatting and git for tracking (!!). Refactoring is as easy as with code, while it was the most manual and painful thing in GnuCash. Python plugins are a breeze and I already made a few while I never surpassed the inertia of automating GnuCash. The web UI makes reports more intuitive than anything in GnuCash, and there’s an SQL language for custom stuff. And finally, I can assert more things I care about and leave flexible more things I don’t. Try Beancount (or any other ledger port I suppose, but yay Python plugins).

                                      2. 2

                                        why not use sqlite or something?

                                        1. 3

                                          Because plain text is much simpler than SQL. You can just open up the file in $EDITOR and start editing, instead of having to run SQL over it to modify.

                                          1. 1

                                            But then if you want to do even the simplest things like sum by month you need to write a text parser first. I get that awk and stuff lets you do things with “tricks” but sqlite would let you do it without worrying about whitespace.

                                            I can understand text-based input, but if you’re trying to track the flow of money by sources in a “real” way it seems pretty logical to use relations

                                            EDIT: this isn’t necessarly pro-SQL, but it is pro-“structured data instead of worrying about escape characters in the format you defined”

                                            Plain text is nice when you have an underspecified format but if you want to actually operate on it, it’s kinda gnarly

                                            1. 5

                                              EDIT: this isn’t necessarly pro-SQL, but it is pro-“structured data instead of worrying about escape characters in the format you defined”

                                              Actually the data is very tightly structured. Here’s what Beancount allows. Any deviations are reported as errors.

                                              But then if you want to do even the simplest things like sum by month you need to write a text parser first.

                                              Generally the tool you’re using takes care of it. I’m using Beancount+Fava and it shows me pretty much every single metric that’s interesting out of the box. For everything else, it allows me to query the “database” using a SQL-like interface.

                                              If you’re interested, I wrote a blog post on exactly this topic last week which could be relevant.

                                        1. 2

                                          This seems a little incomplete. If you revoke your own license to your own code, perhaps you lose the right to the rest of the kernel. But you can still do it. It’s not clear that you can actually waive the right to termination.

                                          1. 16

                                            The inconvenience is not a bug, it’s a feature. Collapsing isn’t so much to spare delicate sensibilities, it’s to be instantly clear to the poster and visitors that these comments are unrepresentative of Lobsters. Only 104 out of the site’s 146,068 comments have hit -5 to default to being collapsed. I’m looking to add, not remove, features that emphasize to these rare posters just how far outside of normal, appropriate community behavior these few comments are.

                                            1. 3

                                              While I agree with the value of not giving bad comments prominence, I think it’s unfortunate that many replies to downvoted comments are good comments, highlighting the values this community approves of. It’s not insult-counterinsult, it’s reasoned responses that take the original comment’s arguments in good faith and engage with them.

                                              I just think it’s unfortunate that the good will be hidden with the bad.

                                              1. 1

                                                Could you please explain then, what it is about this comment that is so “far outside of normal, appropriate community behavior”?

                                                How these emacs.d distributions are “valuable” in any way? If you want to type text and don’t care at all, just get notepad.exe, VS Code, Sublime Text or another silly tool that kids use these days. The thing about Emacs is to just start with bare bones and add features and improvements to your .emacs only if you need to, instead of reusing other people’s configuration which you won’t read or even understand, as it’s mostly overcomplicated to cover extensive cases for many users at once.

                                                And what is the reason for preventing links from working to this reply?

                                                1. 6

                                                  It’s the complete dismissal of a lot of people’s work and favorite tools. Really just the second sentence and “which you won’t read or even understand”. It’s not the technical opinion that these tools are overbuilt or inferior, it’s expressing that opinion as an insult to everyone who uses different tools than the author. If he’d said that he doesn’t see a use for these tools, that he has a much better approach, that there are tradeoffs he thinks people missed or misread, great, it sounds like someone with a considered opinion who wants to discuss these choices. When someone’s convinced they’re right and that people who choose differently did so because they’re incapable of understanding, there’s not much hope for an informative discussion.

                                                  The fundamental issue is not extending charity to recognize that other people’s opinions can have merit or criticizing effectively* to narrow, explore, and maybe resolve the disagreement. And this applies even if the poster is 100% right in every opinion! If it was enough to be right, they could be right alone in their head or in their projects; we collaborate in a community to ask questions, or get answer didn’t know to ask for, or share what we know. It’s bad, counter-productive writing that hurts a community in much the same way as a pile of spaghetti code with a bunch of global variables that sorta works is counter-productive and hurts the overall system.

                                                  Sometimes these comments get responses that are better than them, that ignore the outrageous rhetoric to talk about the fundamental issues in a collaborative way. This one you linked is a great example and I don’t have a good answer for your question. I’ve seen forums that replace deleted comments with a moderator note summarizing them or explaining why they were deleted; it’d mean significantly more deleted comments and mod work so I’m reluctant to adopt it. I’ve also seen forums that allow mods to reparent comments to top-level threads, but that can be really confusion to read. Turning off replies to collapsed comments would have much the same effect, but feels like it would entirely close the door on the better replies. None of these feel like a great solution, like a measured nudge towards community norms that doesn’t reward bad comments with more attention. I’m open to suggestions, and maybe drop in the chat where ideas for these sorts of things get kicked around fairly regularly.

                                                  • I think this four-point framework is very useful but overkill for small disagreements; it’s generally enough to nod in the direction of that level of understanding until you suspect you’re talking past each other, it’s about a very contentious or sensitive topic, or there’s otherwise a reason to proceed more deliberately.
                                                  1. 1

                                                    Well, that’s all well and your opinion, and I see no good reason to collapse that comment.

                                                    As I didn’t see an answer, I ask again:

                                                    And what is the reason for preventing links from working to this reply?

                                                    1. 2

                                                      It’s because it would require some javascript and lobste.rs doesn’t serve javascript (at least to logged out users). In principle it could work for logged in users but someone would need to do the work to add that to the codebase.

                                                  2. 4

                                                    “Could you please explain then, what it is about this comment”

                                                    It was a dismissive type of comment that didn’t look for any value people might have gotten out of the distributions. Then, it had an insult built into it as @steveno highlighted in his reply. Most comments here are disagreements with more technical detail and few insults. That is outside of the baseline even for highly-subjective topics like this.

                                                1. -10

                                                  We don’t need another kilograms of heavy UIs to make people “click ok and get on with things”, we need people to understand how the Git actually works.

                                                  Remember that Git is not a new iPhone and it doesn’t need to be used by idiots, morons and people with zero knowledge - actually, it lifts the bar a bit, but if you sit down and focus on how Git really works, you’ll grasp the ability to answer yourself a question “What I need to do to achieve that…?” in less than a hour.

                                                  Instead of copying and pasting magic spells from Stuck Overblown.

                                                  1. 22

                                                    Please could you not be this acerbic here in future? Thanks.

                                                    1. 5

                                                      I think both sides are right, people could become more expert at easier tools. The nice thing with this UI is it doesn’t seem to hide the underlying git commands, you can hover over the buttons to see what they do.

                                                      1. 3

                                                        What @0x2ba22e11 said.

                                                        1. 1

                                                          Despite your tone, you’re not entirely wrong when it comes to coders.

                                                          Admittedly Git could do with some overhaul in its command line arguments to make it more logical, but it’s a power tool and it’s possible to wrap your head around it. Not everyone does, but I think they should. Like with their editor/IDE of choice.

                                                          If someone’s more productive with a UI like this and there’s no real detriment, let the markets decide.

                                                          Git can be used to track non-code content, though. The Apollo 17 project comes to mind, as it’s one of my favorite things online.

                                                          I contributed to it using CLI Git, but for less technical people to get involved in things like that, there’s nothing wrong with a GUI.

                                                        1. 14

                                                          I have to disagree, at least partially. A couple years ago I started learning the norman layout on a columnar keyboard (Ergodox, then Planck). I crashed from ~100 wpm to 9 wpm and it took weeks to crawl above 30 wpm (I took regular typing tests). I absolutely was a less productive programmer, and I had plenty of time to think about it as I crawled my way through the days. I think there are two main factors this doesn’t take into account.

                                                          First, I think this back-of-the-envelope calculation is roughly accurate, but it’s about lines of finished code. Producing 100 lines of production code can require producing more than ten times that much in drafts, tests, debugging, typos, and intermediate forms. We’ve all had that day (…or week…) debugging that ends with a one-line fix, right?

                                                          Second, this only accounts for code. A significant amount of my work is communicating with coworkers and users on Slack/email/tickets or writing documentation. That all greatly outweighs the raw code I produce, and I would not be an effective programmer if I wasn’t doing it.

                                                          More subjectively, it’s a distraction to not be able to type quickly. Not just if you’re crawling along at 10 wpm and have to consciously think about each key, but when I was only typing at 40 or 50 wpm I couldn’t get down thoughts as fluidly as I could think them. Above 60 or 70 wpm this faded away and I’d agree that it’s not a bottleneck, but it is a loss of performance.

                                                          1. 8

                                                            More subjectively, it’s a distraction to not be able to type quickly.

                                                            I can’t agree more. I didn’t think text input speed was an issue until I started trying to type code on a phone keyboard. The speed of doing that is just unbearably slow.

                                                            1. 5

                                                              I see what you’re saying, but I think it misses the spirit of the argument in the article, which is probably better summarized as “For developers who can touch-type, the amount of code required to be typed is not a programming bottleneck” We could probably soften the statement a bit more and still get to the heart of what the author saying which is “Exchanging verbosity for functional simplicity and reliability is a net win.” I agree with both of those statements. I don’t think the argument about wpm is even necessary. I’ve failed to ship plenty of features on time, and never once was the problem that I couldn’t type the code in fast enough. That’s never even been close to being a concern. On the other hand, chasing down runtime type errors, shared mutable state, isolated data in invalid states, and similar issues have often cost myself and teammates quite a bit of time. Of course, poor organization and planning can outweigh any of those factors, but when it comes to the actual code, I’ll take verbose stronger guarantees over terse weak contracts any day of the week.

                                                              1. 2

                                                                Notice that the author presents a class with a builder that’s 78 lines alongside the mythical man month finding that programmers produce 10 lines a day.

                                                                Something tells me he would not be ok taking an entire day, or even 8 days(!) to produce it. Reasoning about averages has a lot of pitfalls.

                                                              1. 1

                                                                Is there a list of all of the Lobste.rs sibling communities?

                                                                1. 6

                                                                  Yep: https://github.com/lobsters/lobsters/wiki

                                                                  (There are likely more we’re unaware of; they’re under no obligation to tell us they exist.)

                                                                  1. 2

                                                                    Thank you! very cool to see lobsters being used more!

                                                                    1. 1

                                                                      It’s just such an ingenious piece of code – I’m sure it will end up being used across the whole spectrum of subjects!

                                                                1. 3

                                                                  You should look up on memorization: recording previous function calls and reusing the result when calling with the same arguments. You are doing something very similar by working incrementally on the list of results

                                                                  1. 2

                                                                    Typical memoization isn’t something you can do with just pure functions, but it could be done with an Erlang process storing state. I wanted to keep my implementation simple, so I didn’t spawn a process to store state. If you look at Dave’s Gist that I linked to, it contains an exercise where he does use processes to make his implementation faster. Using a list is an easy way of getting the benefits of memoization using pure functions. The downside is once the functions return no state is retained, unlike memoization which persists across calls.

                                                                    1. 2

                                                                      You can’t do the typical memoization by closing over mutable state, but you can memoize a pure function by making the state an explicit parameter and part of the return value, so fib(nth) -> integer becomes fib(nth, { nth: integer}) -> (integer, { nth: integer). Now fib has a dictionary it can check for memoized values from, and add values to by returning the tuple of result + possibly larger dictionary. (Basically, the state monad.) This is a really lovely design in recursive code like the Fibonacci sequence.

                                                                      1. 2

                                                                        That’s true. I was thinking of memoization in the OO sense where the state is implicit and nothing has to be passed around.

                                                                  1. 8

                                                                    Always a joy to read Conor’s writing :)

                                                                    Note that Epigram has been dead for a while, Idris is its spiritual successor (I believe it actually evolved from an attempt to build an Epigram compiler). Idris is explicitly aiming to be a “real” programming language; Agda is very similar, but is more often used from a mathematical/logical side of Curry-Howard, rather than the programming side.

                                                                    Neither Idris or Agda have the 2D syntax of Epigram, but they both have powerful Emacs modes which can fill in pieces of code (Haskell’s “typed holes” is the same idea, but (as this paper demonstrates) Haskell’s types are less informative).

                                                                    1. 10

                                                                      Indeed, I suppose it’s that Idris evolved from what was intended to be the back end of Epigram. It certainly owes a lot to Conor McBride and James McKinna’s work on Epigram. I don’t know if “real programming language” is exactly the right way to put it, though, so much as being the language I wanted to have to explore the software development potential of dependent types. Maybe “real” will come one day :).

                                                                      1. 1

                                                                        Will we see a longer form post/paper or something that isn’y merely Twitter teasers about Blodwen anytime soon? :)

                                                                        1. 6

                                                                          Hopefully! I know I need to get on with writing things so that more people can join in properly. I have plenty of time to work on it for a change in the next few months, so that’s nice…

                                                                          1. 1

                                                                            Do you have a writeup about it? I’m wondering why you’re replacing Idris which is somewhat established already, I mean that probably is the reason you’re replacing it, but still I wonder what concretely necessitated a whole new language instead of a 2.0

                                                                            1. 6

                                                                              It isn’t a whole new language, it’s a reimplementation in Idris with some changes that experience suggests will be a good idea. So it’s an evolution of Idris 1. I’ll call it Idris 2 at some point, if it’s successful. It’s promising so far - code type checks significantly faster than in Idris 1, and compiled code runs a bit faster too.

                                                                              Also, I’ve tried to keep the core language (which is internally called ‘TTImp’ for ‘type theory with implicits’) and the surface language cleanly separated. This is because I occasionally have ideas for alternative surface languages (e.g. taking effects seriously, or typestate, or maybe even an imperative language using linear types internally) and it’ll be much easier to try this if I don’t have to reimplement a dependent type checker every time. I don’t know if I’ll ever get around to trying this sort of thing, but maybe someone else will…

                                                                              I started this because the Idris implementation has a number of annoying problems (I’ll go into this some other time…) that can only be fixed with some pretty serious reengineering of the core. So I thought, rather than reengineer the core, it would be more fun to see (a) if it was good enough to implement itself, and (b) if dependent types would help in any way.

                                                                              The answer to (a) turned out to be “not really, but at least we can make it good enough” and to (b) very much so, especially when it comes to name manipulation in the core language, which is tricky to get right but much much easier if you have a type system telling you what to do.

                                                                              I don’t have any writeup on any of this yet. It’ll happen eventually. (It has to, really - firstly because nobody ever made anything worthwhile on their own so a writeup is important for getting people involved, and secondly because it’s kind of what my job is :))

                                                                              1. 1

                                                                                I’m so excited by all of this, can’t wait to see what comes out of it, and it can’t come soon enough:D Idris totally reinvigorated my love for programming tbh

                                                                          2. 2

                                                                            I just follow along with the commits. Edwinb is usually pretty good with his commit messages, so you can kind of get a story of the development from that! :)

                                                                            1. 1

                                                                              I’ve got to admit it’s very weird reading a reply by someone with your identical name/spelling, thanks!

                                                                            2. 1

                                                                              What’s Blodwen?

                                                                              1. 2

                                                                                An implementation of Idris in Idris: https://github.com/edwinb/Blodwen/

                                                                                Has a neat implementation of Quantitative Type Theory that I’m hoping to integrate in my own programming language!

                                                                                1. 1

                                                                                  Nice! What’s your language? Btw your second link is broken

                                                                                  1. 3

                                                                                    Fixed! This is mine: https://github.com/pikelet-lang/pikelet - scratching my itch of Rust not being enough like Idris, and Idris being not designed with low level systems programming in mind. Probably won’t amount to much (it’s rather ambitious), but it’s been fun playing around, learning how dependent type checkers work! I still need to learn more about what Epigram and Idris do, but it takes passes of deepening to really get a handle on all the stuff they learned. I’m probably making a bunch of mistakes that I don’t know about yet!

                                                                                    1. 1

                                                                                      Nice logo. Looks harmless and fun.

                                                                                      1. 1

                                                                                        Nice. I’m starting to realize how I wasn’t the only one to have thought “wouldn’t it be nice to have a purely functional systems language with cool types”:D

                                                                                        What I wanted to make was very similar to Idris, but I would’ve put way more focus on lower-level stuff. Honestly, my way of combining it was likely misguided as I was a total rookie back then (still am, but comparatively, I at least know how much I didn’t know…)

                                                                                        1. 1

                                                                                          Oh cool! I’m sure there are others with a similar itch to scratch - it’s just coming into the realm of the adjacent possibility. Pikelet is just my attempt at pushing that process forwards.

                                                                                          We’ve been growing a nice community over at https://gitter.im/pikelet-lang/Lobby - you are most welcome to drop by if you like!

                                                                                      2. 2
                                                                              2. 1

                                                                                Thanks for putting this in context, that’s really useful.

                                                                                Also: sounds like I’m missing a (200x) in the title, if you know the correct year.

                                                                              1. 11

                                                                                The appendix tells the story of how Uncle Bob came up with the SOLID principles

                                                                                But he didn’t.

                                                                                The single responsibility principle has been around for decades. It’s part of the Unix philosophy. ‘Do one thing (and do it well)’. The ‘open-closed principle’ was first stated as such by Bertrand Meyer. The Liskov substitution principle was introduced by Barbara Liskov, hence the name. The ‘interface segregation principle’ is so obvious and trivial that I doubt anyone wrote it down and gave it a name before, filler to make the acronym work. And to describe ‘function arguments’ as some sort of ‘dependency inversion principle’ is truly ludicrous.

                                                                                1. 4

                                                                                  There’s a couple ways to read that sentence, but I think it’s accurate if you don’t read it as saying that Martin invented all of them. I don’t think that’s a fair reading for a few reasons, but the strongest is that Martin wouldn’t have named the LSP after Liskov if he thought he’d created it. Which is unfortunate, because I think he did create that one.

                                                                                  I got curious about SOLID and especially the LSP a few years ago and researched it, which turned into a talk and short book. Liskov wrote about about types in two solo papers and one with Jeanette Wing that defined a “Subtype Requirement”. The LSP we know was formulated by Martin in a 1995 comp.object post, and it’s about code reuse of classes rather than a computer science model of subtyping. It’s clear he was inspired by Liskov, but she did not create a substitution principle (let alone name it after herself) and Martin’s principle is significantly different.

                                                                                  Another reading of the sentence is also accurate: Martin collected the principles in a 2000 paper. He ordered them OLDI; the S did not appear. My research didn’t include when that joined or became the acronym we know, but even if someone else added and ordered it, I think it’s safe to credit Martin as primary author because of his many usenet posts, articles, papers, and books popularizing SOLID.

                                                                                  1. 3

                                                                                    If I may make a correction (I’m not sure if I understood correctly what you meant by your last sentence), the ‘dependency inversion principle’ which is the D of SOLID is not about injecting dependencies, but rather about the direction of dependencies: high level modules should depend on abstractions and not on low level modules.