1. 2

    $home: I’ve been working through the advent of code challenges live on stream (recordings) so I plan to continue doing that this week or at least for however long I make it. Waking up at 6:30 takes quite a toll on me as I can’t seem to fall asleep early enough to get a good eight hours (which seems to be the minimum I require per night) so I’ve mostly been going on 5 and a half to 6 hours’ sleep per night so far. There are a couple PRs to Dramatiq that I’m going to have to merge and one to Molten that I’m going to have to pick up b/c the original author can’t finish it.

    1. 1

      How many viewers? Any revenue from streaming?

    1. 10

      This ends up being less useful than just opening a file with $PAGER.

      If I want to “peek” at files, I would use the preview feature of fzf.

      1. 3

        The idea is you can still see your buffer while peeking. fzf is also much more complex than what I’ve shown.

        1. 2

          Right, but I’m not sure why that’s useful. I don’t expect the filesystem to change while I’m looking at it.

          1. 2

            Let’s say you have run some command line programs that give some output. Now you need to compare this output with some content in a file.

            This lets you still view this output while viewing a file.

            You can use any program to view…The purpose of the repository is to show you can have simple “peek” functionality with a very small command.

            1. 2

              Well, whether I find this useful or not, I’ll at least say I appreciate you sharing this. This may be useful for people to see, to help them realise that there isn’t so much magic in the terminal, and they can piece together their own workflows in a similar fashion.

      1. 1

        What if the $EDITOR path has spaces in it? Shouldn’t it be tmux split-window -p 33 "$EDITOR" $@?

        1. 2

          Yes it should be that. Keep in mind I also expect people to modify this as they need :)

        1. 3

          I don’t get it. Why not use less or head?

          1. 3

            The idea is you can still see your buffer while peeking.

          1. 3

            what file is so important you’re just dying to look at it, but not important enough that you can run less file and get back to your buffer later

            1. 3

              The idea is you can still see your buffer while peeking.

            1. 1

              What is neat about this, is it’s a great example of using generators to achieve this.

              I think the package could be even simpler - I might give it a try for fun. :) Nice work!

              1. 1

                thanks!!!

              1. 21

                So I think I’m a bit late for the big go and rust and garbage collection and borrow checker discussion, but it took me a while to digest, and came up with the following (personal) summary.

                Determining when I’m done with a block of memory seems like something a computer could be good at. It’s fairly tedious and error prone to do by hand, but computers are good at monotonous stuff like that. Hence, garbage collection.

                Or there’s the rust approach, where I write a little proof that I’m done with the memory, and then the computer verifies my proof, or rejects my program. Proof verification is also something computers are good at. Nice.

                But writing the proof is still kind of a pain in the ass, no? Why can’t I have computer generated proofs? I have some memory, I send it there, then there, then I’m done. Go figure out the refs and borrows to make it work, kthxbye.

                1. 18

                  But writing the proof is still kind of a pain in the ass, no? Why can’t I have computer generated proofs? I have some memory, I send it there, then there, then I’m done. Go figure out the refs and borrows to make it work, kthxbye

                  I’m in the middle of editing an essay on this! Long story short, proving an arbitrary code property is undecidable, and almost all the decidable cases are in EXPTIME or worse.

                  1. 10

                    I’m kinda familiar with undecidable problems, though with fading rigor these days, but the thing is, undecidable problems are undecidable for humans too. The impossible task becomes no less impossible by making me do it!

                    I realize it’s a pretty big ask, but the current state of the art seems to be redefine the problem, rewrite the program, find a way to make it “easy”. It feels like asking a lot from me.

                    1. 10

                      The problem is undecidable (or very expensive to decide) in the most general case; what Rust does is solve it in a more limited case. You just have to prove that your usage fits into this more limited case, hence the pain in the ass. Humans can solve more general cases of the problem than Rust can, because they have more information about the problem. Things like “I only ever call function B with inputs produced from function A, function A can only produce valid inputs, so function B doesn’t have to do any input validation”. Making these proofs without computer assistance is no less of a pain in the ass. (Good languages make it easy to enforce these proofs automatically at compile or run time, good optimizers remove redundant runtime checks.)

                      Even garbage collectors do this; their safety guarantees are a subset of what a perfect solution would provide.

                      1. 3

                        “Humans have more information about the problem”

                        And this is why a conservative borrower checker is ultimately the best. It can be super optimal, and not step on your toes. It’s up to the human to adjust the lifetime of memory because only the human knows what it wants.

                        I AM NOT A ROBOT BEEP BOOP

                      2. 3

                        Humans have a huge advantage over the compiler here though. If they can’t figure out whether a program works or not, they can change it (with the understanding gained by thinking about it) until they are sure it does. The compiler can’t (or shouldn’t) go making large architectural changes to your code. If the compiler tried it’s hardest to be as smart as possible about memory, the result would be that when it says “I give up, the code needs to change” the human who can change the code is going to have a very hard time understanding why and what they need to change (since they haven’t been thinking about the problem).

                        Instead, what Rust does is apply as intelligent a set of rules they could that produce consistent understandable results for the human. So the compiler can say “I give up, here’s why”. And the human can say “I know how the compiler will work, it will accept this this time” instead of flailing about trying to convince the compiler it works.

                        1. 1

                          I realize it’s a pretty big ask

                          I’ve been hearing this phrase lately “big ask” from business people generally, seems very odd to me. Is it new or have I just missed it up to now?

                          1. 2

                            I’ve been hearing it from “business people” for a couple years at least, I assume it’s just diffusing out slowly to the rest of society.

                            The new one I’m hearing along these lines is “learnings”. I think people just think it makes them sound smart if they use different words.

                            1. 1

                              A “learning”, as a noun, is attested at least as far back as the early 1900s, FYI.

                              1. 0

                                This sort of comment annoys me greatly. Someone used a word incorrectly 100 years ago. That doesn’t mean it’s ‘been a word for 100 years’ or whatever you’re implying. ‘Learning’ is not a noun. You can argue about the merits of prescriptivism all you like, you can have whatever philosophical discussion you like as to whether it’s valid to say that something is ‘incorrect English’, but ‘someone used it in that way X hundred years ago’ does not justify anything.

                                1. 2

                                  This sort of comment annoys me greatly. Someone used a word incorrectly 100 years ago. That doesn’t mean it’s ‘been a word for 100 years’ or whatever you’re implying. ‘Learning’ is not a noun.

                                  It wasn’t “one person using it incorrectly” that’s not even remotely how attestation works in linguistics. And of course, of course it is very much a noun. What precisely, man, do you think a gerund is? We have learning curves, learning processes, learning centres. We quote Pope to one another when we say that “a little learning is a dangerous thing”.

                                  To take the position that gerunds aren’t nouns and cannot be pluralized requires objecting to such fluent Englishisms as “the paintings on the wall”, “partings are such sweet sorrow”, “I’ve had three helpings of soup”

                                  1. 0

                                    ‘Painting’ is the process of painting. You can’t pluralise it. It’s also a (true) noun, the product of doing some painting. There it obviously can be pluralised. But ‘the paintings we did of the house kept improving the sheen of the walls’ is not valid English. They’re different words.

                                    1. 2

                                      LMAO man, how do you think Painting became a “true” noun? It’s just a gerund being used as a noun that you’re accustomed to. One painted portraits, landscapes, still lifes, studies, etc. To group all these things together as “paintings” was an instance of the exact same linguistic phenomenon that gives us the idea that one learns learnings.

                                      You’re arguing against literally the entire field of linguistics here on the basis of gut feelings and ad hoc nonsense explanations.

                                      1. 0

                                        You’re arguing against literally the entire field of linguistics here on the basis of gut feelings and ad hoc nonsense explanations.

                                        No, I’m not. This has literally nothing to do with linguistics. That linguistics is a descriptivist scientific field has nothing to do with whether ‘learnings’ is a real English word. And it isn’t. For the same reason that ‘should of’ is wrong: people don’t recognise it as a real word. Words are what we say words are. People using language wrong are using it wrong in the eyes of others, which makes it wrong.

                                        1. 1

                                          That linguistics is a descriptivist scientific field has nothing to do with whether ‘learnings’ is a real English word. And it isn’t. For the same reason that ‘should of’ is wrong: people don’t recognise it as a real word. Words are what we say words are.

                                          Well, I hate to break it to you, but plenty of people say learnings is a word, like all of the people you were complaining use it as a word.

                                          1. 0

                                            There are lots of people that write ‘should of’ when they mean ‘should’ve’. That doesn’t make them rightt.

                                            1. 1

                                              Yes and OK is an acronym for Oll Korrect, anyone using it as a phrase is not OK.

                                              1. 0

                                                OK has unknown etymology. And acronyms are in no way comparable to simply incorrect grammar.

                                                1. 1

                                                  Actually it is known. Most etymologists agree that it came from Boston in 1839 originating in a satirical piece on grammar. This was responding to people who insist that English must follow some strict unwavering set of laws as though it were a kind of formal language. OK is an acronym, and it stands for Oll Korrect, and it was literally invented to make pedants upset. Certain people were debating the use of acronyms in common speech, and to lay it on extra thick the author purposefully misspelled All Correct. The word was quickly adopted because pedantry is pretty unpopular.

                                                  1. 1

                                                    What I said is that there is what is accepted as valid and what is not. Nobody educated thinks that ‘should of’ is valid. It’s a misspelling of ‘should’ve’. Nobody thinks ‘shuold’ is a valid spelling of ‘should’ either. Is this really a debate you want to have?

                                                    1. 1

                                                      I was (mostly) trying to be playful while also trying to encourage you to be a little less litigious about how people shuold and shuold not use words.

                                                      Genuinely sorry for making you actually upset though, I was just trying to poke fun a little for getting a bit too serious at someone over smol beans, and I was not trying to make you viscerally angry.

                                                      I also resent the attitude that someone’s grammatical or vocabulary knowledge of English represents an “education”.

                            2. 1

                              It seems like in the last 3 years all the execs at my company started phrasing everything as “The ask is…” I think they are trying to highlight that you have input (you can answer an ask with no) vs an order.

                              In practice, of course, many “asks” are orders.

                              1. 4

                                Sure, but we already have a word for that, it’s “request”.

                                1. 4

                                  Sure, but the Great Nouning of Verbs in English has been an ongoing process for ages and continues apace. “An ask” is just a more recent product of the process that’s given us a poker player’s “tells”, a corporation’s “yearly spend”, and the “disconnect” between two parties’ understandings.

                                  All of those nouned verbs have or had perfectly good non-nominalized verb nouns, at one point or another in history.

                                  1. 1

                                    One that really upsets a friend of mine is using ‘invite’ as a noun.

                              2. 1

                                Newly popular? MW quotes this usage and says Britishism.

                                https://www.merriam-webster.com/dictionary/ask

                                They don’t date the sample, but I found it’s from a 2008 movie review.

                                https://www.spectator.co.uk/2008/10/cold-comfort/

                                So at least that old.

                            3. 3

                              You no doubt know this, but the undecidable stuff mostly becomes decidable if you’re willing to accept a finite limit on addressable memory, which anyone compiling for, say, x86 or x86_64 is already willing to do. So imo it’s the intractability rather than undecidability that’s the real problem.

                              1. 1

                                It becomes decidable by giving us an upper bound on the number of steps the program can take, so should require us to calculate the LBA equivalent of a very large BB. I’d call that “effectively” undecidable, which seems like it would be “worse” than intractable.

                                1. 2

                                  I agree it’s, let’s say, “very” intractable to make the most general use of a memory bound to verify program properties. But the reason it doesn’t seem like a purely pedantic distinction to me is that once you make a restriction like “64-bit pointers”, you do open up a bunch of techniques for finite solving, some of which are actually usable in practice to prove properties that would be undecidable without the finite-pointer restriction. If you just applied Rice’s theorem and called verifying those properties undecidable, it would skip over the whole class of things that can be decided by a modern SMT solver in the 32-bit/64-bit case. Granted, most still can’t be, but that’s why the boundary that interests me more nowadays is the “SMT can solve this” vs. “SMT can’t solve this” one rather than the CS-theory sense of decidable/undecidable.

                            4. 6

                              Why can’t I have computer generated proofs? I have some memory, I send it there, then there, then I’m done.

                              It’s really hard. The main tool for that is separation logic. Manually doing it is harder than borrow-checking stuff. There are people developing solvers to automate such analyses. Example. It’s possible what you want will come out of that. I think there will still be restrictions on coding style to ease analyses.

                              1. 3

                                In my experience, automated proof generators are very leaky abstractions. You have to know their search methods in detail, and present your hypotheses in a favorable way for those methods. It can look very clean, but it can mean that seemingly easy changes turn out to be frustrated by the methods’ limitations.

                                1. 4

                                  I’m totally with you on this. Rust very much feels like an intermediate step and I don’t know why they didn’t take it to it’s not-necessarily-obvious conclusion.

                                  1. 5

                                    In my personal opinion, it might be just that we’re happy that we can actually get to this intermediate point (of Rust) reliably enough, but have no idea yet how to get to the further point (conclusion). So they took it where they could, and left the subsequent part as an excercise for the reader… I mean, to be explored by future generations of programmers, hopefully.

                                    1. 4

                                      We have the technology, sort of. Total program analysis is really expensive though, and the workflow is still “edit some code” -> “compile on a laptop” -> repeat. Maybe if we built a gc’ed language that had a mode where you push your program to a long running job on a compute cluster to figure out all the memory proofs.

                                      This would be especially cool if incrementals could be cached.

                                      1. 4

                                        I’ve recommended that before. There’s millions being invested into SMT/SAT solvers for common bugs that might make that happen, too. Gotta wait for the tooling to catch up. My interim recommendation was a low-false-positive, static-analysis tool like RV-Match to be used on everything in the fast path. Anything that passes is done no GC. Anything that hangs or fails is GC’d. Same with automated proofs to eliminate safety checks. If it passes, remove that check if that’s what pass allows. If it fails, maybe it’s safe or maybe tool is too dumb. Keep the check. Might not even need cluster given number of cores in workstations/servers and efficiency improvements in tools.

                                      2. 4

                                        I think it’s because there’s essentially no chance that a random piece of code will be provable in such a way. Rust encourages, actually to the point of forcing, the programmer to reason about lifetimes and ownership along with other aspects of the type as they’re constructing the program.

                                        I think there may be a long term evolution as tools get better: the languages checks the proofs (which, in my dream, can be both types and more advanced proofs, say that unsafe blocks actually respect safety), and IDE’s provide lots of help in producing them.

                                        1. 2

                                          there’s essentially no chance that a random piece of code will be provable in such a way

                                          There must be some chance; rust is already proving memory safety.

                                          Rust forces us to think about lifetimes and ownership, but to @tedu’s point, there doesn’t seem be much stopping it from inferring those lifetimes & ownership based upon usage. The compiler knows everywhere a variable is used, why can’t it determine for us how to borrow it and who owns it?

                                          1. 17

                                            Rust forces us to think about lifetimes and ownership, but to @tedu’s point, there doesn’t seem be much stopping it from inferring those lifetimes & ownership based upon usage. The compiler knows everywhere a variable is used, why can’t it determine for us how to borrow it and who owns it?

                                            This is a misconception. The Rust compiler does not see anything beyond the function boundary. That makes lifetime checking efficient. Basically, when compiling a function, the compiler makes an reasonable assumption about how input and output references are connected (the assumption is “they are connected”, also known as “lifetime elision”). This is an assumption communicated the outside world. If this assumption is wrong, you need to annotate lifetimes.

                                            When compiling, the compiler will check if the assumption holds for the function body. So, for every function call, it will check if the the signature holds (lifetimes are part of the function signature).

                                            Note that functions with different lifetime annotations taking the same data might differ in their behaviour. It also isn’t always obvious to the compiler whether you want references to be bound together or not and that situation might be ambigous.

                                            The benefit of this model is that functions only need to be rechecked/compiled when they actually change, not some other code somewhere else in the program. It’s very predictable and errors are local to the function.

                                            1. 2

                                              I’ve been waiting for you @skade.

                                              1. 2

                                                Note that functions with different lifetime annotations taking the same data might differ in their behaviour.

                                                I wrote this late at night and have some errata here: they might differ in their behaviour wrt. lifetime checking. Lifetimes have no impact on the runtime, an annotation might only prove something safe that the compiler previously didn’t see as safe.

                                              2. 4

                                                Maybe I’m misunderstanding. I’m interpreting “take it to its conclusion” as accepting programs that are not annotated with explicit lifetime information but for which such an annotation can be added. (In the context of Rust, I would consider “annotation” to include choosing between &, &mut, and by-move, as well as adding .clone() when needed, especially for refcount types, and of course adding explicit lifetimes in cases that go beyond the present lifetime elision rules, which are actually pretty good). My point is that such a “smarter compiler” would fail a lot of the time, and that failures would be mysterious. There’s a lot of experience around this for analyses where the consequence of failure is performance loss due to not being able to do an optimization, or false positives in static analysis tools.

                                                The main point I’m making here is that, by requiring the programmer to actually provide the types, there’s more work, but the failures are a lot less mysterious. Overall I think that’s a good tradeoff, especially with the present state of analysis tools.

                                                1. 1

                                                  I’m interpreting “take it to its conclusion” as accepting programs that are not annotated with explicit lifetime information but for which such an annotation can be added.

                                                  I’ll agree with that definition

                                                  My point is that such a “smarter compiler” would fail a lot of the time, and that failures would be mysterious.

                                                  This is where I feel we disagree. I feel like you’re assuming that if we make lifetimes optional that we would for some reason also lose the type system. That was not my assumption at all. I assumed the programmer would still pick their own types. With that in mind, If this theoretical compiler could prove memory safety using the developer provided types and the inferred ownership, why would it still fail a lot?

                                                  where the consequence of failure is performance loss due to not being able to do an optimization

                                                  That’s totally understandable. I assume like any compiler, it would eventually get better at this. I also assume lifetimes become an optional piece of the program as well. Assuming this compiler existed it seems reasonable to me that it could accept and prove lifetimes provided by the developer along with inferring and proving on it own.

                                                  1. 3

                                                    Assuming this compiler existed it seems reasonable to me that it could accept and prove lifetimes provided by the developer along with inferring and proving on it own.

                                                    That’s what Rust does. And many improvements to Rust focus on increasing the number of lifetime patterns the compiler can recognize and handle automatically.

                                                    You don’t have to annotate everything for the compiler. You write code in patterns the compiler understands, and annotate things it doesn’t. So Rust has gotten easier and easier to write as the compiler gets smarter and smarter. It requires fewer and fewer annotations / unsafe blocks / etc as the compiler authors discover how to prove and compile more things safely.

                                                2. 4

                                                  Rust forces us to think about lifetimes and ownership, but to @tedu’s point, there doesn’t seem be much stopping it from inferring those lifetimes & ownership based upon usage. The compiler knows everywhere a variable is used, why can’t it determine for us how to borrow it and who owns it?

                                                  I wondered this at first, but inferring the lifetimes (among other issues) has some funky consequences w.r.t. encapsulation. Typically we expect a call to a function to continue to compile as long as the function signature remains unchanged, but if we infer the lifetimes instead of making them an explicit part of the signature, subtle changes to a function’s implementation can lead to new lifetime restrictions being inferred, which will compile fine for you but invisibly break all of your downstream callers.

                                                  When the lifetimes are an explicit part of the function signature, the compiler stops you from compiling until you either fix your implementation to conform to your public lifetime contract, or change your declared lifetimes (and, presumably, since you’ve been made conscious of the breakage in this scenario, notify your downstream and bump your semver).

                                                  It’s basically the same reason that you don’t want to infer the types of function arguments from how they’re used inside a function – making it easy for you to invisibly breaking your contract with the outside world is bad.

                                                  1. 3

                                                    I think this is the most important point here. Types are contracts, and contracts can specify far more than just int vs string. Complexity, linearity, parametricity, side-effects, etc. are all a part of the contract and the more of it we can get the compiler to enforce the better.

                                            2. 1

                                              Which is fine, until you have time or memory constraints that are not easily met by the tracing GC, which is all software of sufficient scale or complexity. At that point, you end up with half-assed and painful to debug/optimize manual memory management in the form of pools, ect.

                                              1. 1

                                                Or there’s the rust approach, where I write a little proof that I’m done with the memory, and then the computer verifies my proof, or rejects my program. Proof verification is also something computers are good at. Nice.

                                                Oh I wish that were how Rust worked. But it isn’t. A variant of Rust where you could actually prove things about your programme would be wonderful. Unfortunately, in Rust, you instead just have ‘unsafe’, which means ‘trust me’.

                                              1. 3

                                                Interesting but…such a cheesy design. Come on. I also don’t see a good “why” other than “because I can”. There is probably a good evolutionary reason we don’t have some obvious indicator.

                                                Props to her regardless for exploring the space a bit.

                                                1. 9

                                                  She speaks pretty concretely about her motivations towards the end of the video.

                                                  1. 1

                                                    Fair enough, I literally watched it to where she demonstrated it and I closed the video.

                                                  2. 4

                                                    There is probably a good evolutionary reason we don’t have some obvious indicator.

                                                    We do, for various things.

                                                    1. 2

                                                      There is probably a good evolutionary reason we don’t have some obvious indicator.

                                                      There’s a good, evolutionary reason we get torn up by bacteria and parasites. What’s good for evolution’s goals isn’t necessarily good for a human individual. There’s also unnecessary limits given we can use tech to push past them if we choose.

                                                    1. 3

                                                      Asus E403SA. I bought mine used for $100.

                                                      • 1080p 14” display
                                                      • 128 GB EMMC storage
                                                      • 4 GB RAM
                                                      • Quadcore Intel Pentium

                                                      It is so nice.

                                                      1. 3

                                                        Maybe people should have a little think about how other careers work. As a lawyer, what’s the ‘next career step’ for people that have been working for 10 years as lawyers? It is of course to work for another 35 years as a lawyer and then retire, possibly becoming a partner in a law firm at some point.

                                                        If you want to make more money that you make as an employee, you need to not be an employee. It’s pretty simple. Call it management, call it whatever you want. But fundamentally as an employee you cannot make any more than you generate in revenue for whatever company you work for, and realistically you’ll be making much less because otherwise they won’t generate any profit. If you want to make more money that you can generate in ‘value’ per hour, or even anywhere near that amount, you’re going to need to start extracting profits from the work of others. Distasteful, I know, but that’s what you want.

                                                        1. 2

                                                          Not sure where you’re getting that. Fair-sized law firms have a clear career/promotion progression. More senior lawyers have management responsibilities.

                                                          That said - you’re correct that the real money doesn’t roll in until you buy a partnership and start extracting profits from others work.

                                                          1. 1

                                                            Fair-sized law firms have a clear career/promotion progression. More senior lawyers have management responsibilities.

                                                            Exactly the same is true of software yet software developers seem always to be concerned that there are not enough ‘senior technical roles’.

                                                          2. 2

                                                            As a lawyer, what’s the ‘next career step’ for people that have been working for 10 years as lawyers? It is of course to work for another 35 years.

                                                            Definitely saving this one. Great example miles.

                                                          1. 20

                                                            “The next career step”

                                                            Why does there always have to be a next step?

                                                            Why can’t we become extremely knowledgeable and continue to just grow our knowledge?

                                                            My goal in life is to not move up the career ladder but to grow my foundations such that they are so strong my ability to do everything as perfect as possible increases.

                                                            And then spend the rest of my life reading and going fishing.

                                                            1. 2

                                                              So you can retire much earlier😀

                                                              1. 2

                                                                I don’t really care what it is called as long as I get compensated more.

                                                              1. 3

                                                                Maybe advertisers need to change their model. Why should ads be based on clicks anyway? You can’t click on billboards. You can’t click on bus stops. You can’t click on newspapers. Advertising isn’t a way of inserting links to your website into other peoples’ products, it’s a way of putting yourself out there.

                                                                If you put an advertisement on my website and I get X traffic per month, then you know that your advertisement has been seen by X people in that month. That’s worth some amount of money. I don’t know how much. It depends on a lot of factors.

                                                                Advantages of this model: you reach tech people. Tech people have a lot of money and use adblockers that will block your ads if you use any other model. They’re a great target for advertising. They are reached by few other ads: they don’t watch broadcast TV much, for example. They’re more likely to read online news website with adblock than to read newspapers.

                                                                Disadvantages of this model: you can’t track every detail of peoples’ personal lives and infect their computers with malware and indestructible super cookies.

                                                                And to be clear, you can still make the ad a link. It’s just not pay-per-click but pay-per-approximate-pageview.

                                                                1. 2

                                                                  Well this is what Google does. Page views. This is much closer to your billboard example, where people can only look. I assume billboard prices are based on where a billboard is located/how popular of a spot. This mirrors popular websites where many eyeballs will be.

                                                                1. 4

                                                                  I love these, and I’m fascinated by this style of programming, but does anyone here have any real-world experience using this or tools like this to accomplish anything? I’d love to read some anecdotes about industrial uses of logic programming and/or constraint solving (and for the record, yes, I’m familiar with Watson, I mean any personal experience).

                                                                  1. 9

                                                                    I’ve used this before when building supply ordering systems for production processes. At the time, we had a number of supplies which figured out the old way of ordering widgets (buy from whoever can give us everything in a single shipment) and they started to price gouge us. I came in and rewrote it as a constraint problem, allowing us to split all of the shipments based off of arrival time, cost of shipping and cost of goods. Ended up working really well, after about two months the suppliers had to shift to a better pricing model or loose out on our business.

                                                                    1. 3

                                                                      I would like to hear more about this. Maybe good to write an article vs lobsters comment.

                                                                      1. 3

                                                                        fascinating! thank you for responding.

                                                                      2. 7

                                                                        It’s not “industrial” experience, but for the Hy language, I built a static analysis tool that can suggest code transformations and the like, called hydiomatic. The transformation rules are built in miniKanren, and look like this:

                                                                        ;; (+ x (+ ...)) => (+ x ...)
                                                                        [`(+ ~?x (+ . ~?xs)) `(+ ~?x . ~?xs)]
                                                                        

                                                                        Adding similar rules is incredibly easy, all thanks to miniKanren. The tool is modeled after a similar tool for Clojure, kibit. Rules are applied recursively, until no more transformations are possible, so things like (+ 1 (+ 2 (+ 3 (+ 4)))) become (+ 1 2 3 4) in the end.

                                                                        I also built a (now defunct) tool to help me arrange windows, also based on miniKanren: wynck.

                                                                        All of these provided solutions for things I needed, and did so much more elegantly than if I had to do them without using miniKanren.

                                                                        1. 1

                                                                          wow, so thats really cool! and serendipitous, I just started getting back to python yesterday. I’m really intrigued by this though, I see the note about “limitations” in the readme, it seems like you’d be hard pressed to make gains with a tool like this, isn’t this essentially an NP-complete task?

                                                                          1. 2

                                                                            There are lots of problem domains out there where the general case is NP-Hard, but real world examples are usually tractable.

                                                                      1. 2

                                                                        I recently discovered PlusCal which is built on TLA+, which this lang is said to be inspired by. I encourage readers to check it out too. Leslie Lamport made both (PlusCal and TLA+).

                                                                        1. 2

                                                                          I’m already suggesting to people to use ChromeOS through VNC to access the web. I say this to make them realize that the web is heavily controlled by Google.

                                                                          IMO, the faster we can get this to happen, the faster people will see why this sucks.

                                                                          And then we can start over.

                                                                          All the while, Web3 will develop.

                                                                          1. 6

                                                                            People wouldn’t care anyways, they just want to click ok and get on with things no matter which measure it’ll involve. Cat GIFs, Netflix’n’chill and “work e-mail” are more important than the fact you’re being fscked by Google or not. Especially in NA, Europeans seem to still pay a little attention, but it’s falling too.

                                                                            1. 2

                                                                              Yep, you are totally right. This is why I think ChromeOS plus improvements to their documents platform and YouTube (watch YouTube offer music next) will eventually win out. The only thing Google is missing are games.

                                                                              Now what would be insane is if Google bought Valve.

                                                                              1. 4

                                                                                You can’t just unilaterally buy a company. The people that own it have to want to sell. And no way in hell is Gabe Newell selling Valve to Google.

                                                                                1. 1

                                                                                  You can, if it’s public. It’s called a “hostile takeover” and involves buying enough stock to own a vote-proof majority stake.

                                                                                  1. 4

                                                                                    valve is not a public company…

                                                                                    1. 2

                                                                                      I did not know that.

                                                                                2. 3

                                                                                  watch YouTube offer music next

                                                                                  Already happened? https://www.youtube.com/musicpremium or the older https://play.google.com/music/listen

                                                                                  1. 1

                                                                                    Ah, there you go. Now they need to just heavily develop it and maybe re-brand.

                                                                                  2. 4

                                                                                    But what do you think about people actually using computer for serious (not strictly IT related, so I’m intentionally omitting programming/data science/gamedev) tasks, not limited to content consumption?

                                                                                    • CAD
                                                                                    • DTP/graphics design
                                                                                    • Music production/DAWs (side note: due to this overall “macdonaldizing” of modern computing, people in music production community are often going “dawless” using only bare metal, often analog, hardware to generate and process their tracks, sometimes using a computer only for final track mix/postproc, but recently there’s a trend to release a hardware to arrange that too - Elektron Octatrack, Synthstrom Deluge, MPC X, and so on)
                                                                                    • Medical data processing/analyzing (MRI)
                                                                                    • countless other industry-specific tasks being actually made easier by using computers, as they’re the reason why computers have been made useful out of the universities

                                                                                    How they have to survive in next decades? I think in next 10 years Windows won’t be a “pro” platform anymore (dropping Win32 is their only hope now) but mostly meant to click on the internet and do normie stuff, maybe gaming (by adopting current-gen Xbox runtime on regular PCs), macOS is already only a shadow of its former glory. Desktop Linux is more likely to be a thing than never before (Valve’s recent revelations, kernel being legally pwned by top modern Silicon Valley giants, and so on) but I can’t really imagine all of that industry stuff being ported on Linux, even if I know about some porting R&D happening for some large products, but they’re more or less taken as a pet projects, even internally.

                                                                                    1. 7

                                                                                      I think in next 10 years Windows won’t be a “pro” platform anymore (dropping Win32 is their only hope now)

                                                                                      Microsoft cannot drop Win32. Such a thing entirely kills Windows, which is still a good cash cow, and creating a new OS, which is what they’d be left to supposing your drop of the most important asset, is a waste of resources. I’m not sure what replacement you could possibly have in mind while still calling it Windows. Nothing big is about to happen there within your 10 years. Maybe afterwards. It’s like with UNIX/POSIX, that won’t die either anytime soon.

                                                                                      It’s easy to be blinded by consumers. There is still going to be large demand for “serious” software, though it might become reconceptualized with AR and other interfaces. You cannot remove the need, you can change the means.

                                                                                      1. 4

                                                                                        For “serious” users, nothing will change. There will be less vendors maybe, but the amount of “custom computing” (GENERAL PURPOSE COMPUTING) will always be massive in academia and business. We are not at risk.

                                                                                        1. 1

                                                                                          And at prices that only academia and business can afford. I think the era of “home computer” (that is a general purpose computer) is nearly dead, if not already dead.

                                                                                          1. 1

                                                                                            I think the era of “home computer” (that is a general purpose computer) is nearly dead, if not already dead.

                                                                                            I think you are right, makes me happy I was part of the generation that got to see the computer and internet sort of come of age.

                                                                                      2. 1

                                                                                        Now what would be insane is if Google bought Valve.

                                                                                        Valves don’t actually make games. For distributing games, gooble already has the play store.

                                                                                        1. 3

                                                                                          It’s not about making games. It’s about having the platform, and every juicy piece of data that comes with.

                                                                                          1. 2

                                                                                            They do make some games, Half-Life series, Portal series, Dota 2 and Artifact for example

                                                                                          2. 1

                                                                                            The only thing Google is missing are games.

                                                                                            Google Play Games - Quite a few (the majority?) of games on Android use this.

                                                                                            1. 1

                                                                                              I don’t know any AAA games released on Google Play. But that’s next I guess.

                                                                                              1. 1

                                                                                                Well, Hearthstone for one. I’d argue that’s an AAA game.

                                                                                                That said, non “AAA” titles also make up a lot of the market. Quite a lot of people who wouldn’t be caught playing on a PC or console play games casually on their smartphone (candy crush type stuff). It makes a lot of money.

                                                                                      1. 4

                                                                                        So while I agree with what alexandria said, this is actually frickin’ fantastic.

                                                                                        I installed it and gave it a go for its money. Browsed reddit a bit, looked at the help, navigated with annotations…so frickin’ sweet! This is so, so impressive. I’m actually wondering how you have made something so good and professional and are giving it for free. You are a saint.

                                                                                        And top of all this, the plugin API…is frickin’ sweet itself. Tailored voice controlled sites is the way to go, and here you have created a super easy way to do that.

                                                                                        I guess you could create a company that creates these tailored experiences.

                                                                                        I’m definitely keeping this extension installed, and I don’t say that too often :) Hey, how about you create a plugin for lobste.rs? :D

                                                                                        23:51 EST: I see the source is not open. How can I be sure your extension is not recording what I’m saying, browsing, etc? (Obviously there are non-invasive ways to check, but still)

                                                                                        I was thinking as an improvement, have an option to keep annotations on always. It is annoying to say “annotate” all the time. As well as “go back” when “back” or “forward” suffice.

                                                                                        What are you using for speech recognition underneath?

                                                                                        1. 1

                                                                                          Thanks for your feedback!

                                                                                          Hey, how about you create a plugin for lobste.rs? :D

                                                                                          I probabably will, if no one else does it before me: https://github.com/lipsurf/plugins

                                                                                          23:51 EST: I see the source is not open.

                                                                                          The core of it is not open source, but as it is just a chrome extension and written using JS, the source is always visible and verifiable technically

                                                                                          I was thinking as an improvement, have an option to keep annotations on always. It is annoying to say “annotate” all the time. As well as “go back” when “back” or “forward” suffice.

                                                                                          The annotations should be staying on? I definitely need to improve those (spent too much time doing Japanese support recently) Also just saying “back” or “forward” should also work, check out the options where you can see all the command words for each plugin.

                                                                                        1. 5

                                                                                          There’s more to life than HTTP

                                                                                          Agreed.

                                                                                          I’ve found MQTT to be a good alternative to HTTP for real-time (or extremely stateful) applications, especially those that exist outside of a web browser. Whenever there is overlap with the web, it is fairly easy to tunnel MQTT over WebSockets.

                                                                                          1. 0

                                                                                            How does MQTT fair against HTTP with billions of users? HTTP has the advantage here for not needing to be stateful.

                                                                                            As the article says too: sometimes HTTP makes sense. IMO the title should have something like “You should use a real pub/sub broker, not HTTP - VerneMQ is one”.

                                                                                            1. 11

                                                                                              You don’t have billions of users. Or if you do, you’re unusual, and shouldn’t be making technology decisions based on blog posts.

                                                                                              1. 2

                                                                                                I can’t say much for VerneMQ, but most of the solutions out there were built for very large scale.

                                                                                                The broker I use (RabbitMQ) supports MQTT and supposedly handles one million requests per second although I’ve never dealt with that much traffic first hand. I’ve heard similar stories for the MQTT product that IBM sells.

                                                                                            1. 2

                                                                                              Anyone have a source for the cause of death? Or any news article?

                                                                                              1. 7

                                                                                                First time I’ve actually felt a sinking feeling in my chest for an Internet person. Terry, you are with God now.

                                                                                                1. 11

                                                                                                  You should add Paperkast to the list of sister sites.

                                                                                                  1. 2

                                                                                                    Done. Thank you very much for the suggestion.

                                                                                                    1. 1

                                                                                                      Maybe there should be some sort of standardized directory?…

                                                                                                      1. 2

                                                                                                        How is https://github.com/lobsters/lobsters/wiki not a standardized directory?

                                                                                                        1. 4

                                                                                                          I suppose it is, but it was not obvious to discover.

                                                                                                          1. 1

                                                                                                            I also wish I’d discovered it sooner. However, other than nesting it under the “Wiki” link at the bottom page, I don’t see a solution that wouldn’t start cluttering up the site with information most people won’t need.

                                                                                                            1. 3

                                                                                                              It’s linked from the about page.

                                                                                                        2. 1

                                                                                                          Can you expand it a little bit?