1.  

    I would be careful to design and implement the compiler so that it could be embedded in different runtimes, and I would have two primary targets: an LLVM based one creating a standalone binary on the mainstream UNIX and windows OSes, and a WASM target that would be intended to use the host VM’s runtime for threads, garbage collection, and so on.

    Instead of having this language target LLVM and WASM, why don’t we have the language target something that compiles to both of these: Rust!

    I love the ideas that this article brings about what can stay in and what can go, but (almost, see below) all of the features they propose can be implemented as a subset or syntactic sugar upon Rust. So why not create a simplified DSL that compiles to Rust. We can get rid of some complexity, leverage all the work that Mozilla has put into a more friendly compiler frontend, and get both of our compiler targets for free.

    The one thing that we can’t get from this is garbage collection, but I don’t like garbage collection, and this is my rant, so I would say we keep the lack of GC ;)

    1.  

      The one thing that we can’t get from this is garbage collection, but I don’t like garbage collection, and this is my rant, so I would say we keep the lack of GC ;)

      It’s absolutely possible to write a garbage-collecting runtime in Rust, so no reason to give up on that requirement (aside from you not liking it :) ).

      1.  

        I feel like it would add a significant amount of complexity to the language, especially since if we’re generating Rust we by default shouldn’t need a GC. Plus, I like the idea of the language not having a runtime, but that’s more from my personal struggles of trying to write OS code in Go and being stung by a complex runtime I had to implement first.

      2.  

        Instead of having this language target LLVM and WASM, why don’t we have the language target something that compiles to both of these: Rust!

        Wouldn’t the compilation overhead of Rust be a bit of a burden? (Time-wise)

        1.  

          You could compile straight to MIR to shave a bit of compilation time off.

          1.  

            Raw MIR doesn’t have things like privacy checking, type inference, or a stable source representation. I’m not even sure that’s it’s really memory-safe without all the up-front checking that rustc performs on the HIR. You’d be better off compiling to C.

      1. 4

        It seems like spreadsheets have some of the benefits of Jupyter Notebooks (live coding), RAD GUI builders, and cross platform virtual machines (run the same program on an iPad, a desktop, and in the web). There are very real downsides to spreadsheets, but it would require incredible amounts of engineering work to match the benefits they provide.

        1. 4

          Flying to California for a week of camping and hanging out with old friends on the beach and in the trees.

          Speaking of which, any book recommendations? Genre or subject is irrelevant so long as the book is good. I just loaded Hallucinations by Sacks onto my ereader but that will probably not last the week.

            1. 2

              Thanks for the suggestions! I’ve never read Simmons, but I’ll check this out. And Vonnegut is always fun.

              1. 1

                Thanks, added to the list.

                1. 1

                  This seems pretty interesting. Thanks!

                2. 1

                  The Three Body Problem Trilogy. My favorite Sci-Fi series.

                  1. 1

                    I’ll download it and add to the list. Thanks!

                1. 9

                  And your eyes are swimming, and you have no friggin’ idea what this frigtard is talking about, but he just won’t go away, and even if he does go away, he’s just going back into his office to write more of his clever […]

                  This was surprisingly triggering for me. As someone who tries to share (what I think are) neat bits of tech trivia and then get slammed as a nerd (in a room full of programmers no less) this is really demotivating. I know you need to “know your audience”, but people also tell you to “put yourself out there”. Persistence seems to be key: eventually you’ll find like-minded people. Eventually…

                  1. 5

                    I have a feeling you could have brought up the weather, or last night’s sportsball game, and the response would have been the same.

                    This biz does not seem to attract the nicest people. Look at how JWZ responds to people on his own blog… when they’re trying to help! I think JWZs are the rule in software rather than the exception.

                    1. 1

                      I think it’s just a mistake to think there are many interesting categories that include ADTs and CORBA and let you make generalizations about them. Talking about “abstractions” without making clear which kind of examples you’re talking about is way too common, though.

                    1. 8

                      I got my assembler to the point where I could print “hello world”. It feels kind of cool making a program using your own code. I’m going to see if I can automate adding more instructions this weekend. This is for a compiler so I’m also starting to think about the IR and the language itself. I think I’d like to make a bare-metal language with dependent types, but I don’t think I’m smart enough for that. I’d like a type system that is at least as capable as Rust’s, but even that seems difficult.

                      1. 1

                        Which machine language are you targeting? x86-64?

                        1. 1

                          Yes I’m targeting AMD64. If this compiler takes off I’d like to target other architectures but I think that would be wasted effort until the compiler is self-hosting. It would be really nice to target something straightforward but AMD64 is what I use for development so anything else would just be annoying.

                          1. 1

                            That’s ambitious! One of these days I should take a look at a few existing code generators for AMD64. Things like register allocation are still a mystery to me.

                        2. 1

                          but I don’t think I’m smart enough for that

                          Judging by what you’ve done so far, you definitely are smart enough to do that.

                          1. 3

                            I appreciate it, but I don’t think writing an assembler takes a genius. It’s sort of hard to figure out all of the corner cases for instruction encoding but it just takes time. Meanwhile I’ve been trying to understand dependent types for 6 months now and I still don’t get it. I’ll try to experiment a bit again, maybe it’ll click.

                            1. 2

                              Yeah, sometimes understanding a concept really requires implementing it.

                              1. 1

                                When you figure out dependent types, please explain it, with a language other than Haskell :)…

                                Sometimes I think terms like “Dependent Types” and “Monads” are just because Haskell folks refuse to admit that their ideas might be simple enough to explain with simple off the shelf words. :)

                          1. 2

                            I could adapt computer work to solar conditions. There’s a remarkable difference in power use for the laptop between writing (roughly 15W) and surfing the web (roughly 25W). In other words, I can work almost twice as long when I’m writing, which I could do whenever available energy is low.

                            I’ve been impressed by Opera’s battery saver mode. It substantially increases my battery life on my debian laptop. (6 hours vs 3-4 w/ Firefox and Chrome) I’ve also heard good things about Safari’s power usage on macs.

                            Additionally, I saw a review for the ARM version of the Lenovo Yoga. It sports an incredible 25 hour battery life. Makes you wonder what an ARM laptop future would look like for off the grid users.

                            1. 5

                              When my mental health/wellness was not so great I was down to 3 - 4 hours a day and some days were total blowouts. Nowdays it’s closer to 5 - 7 hours usually. Sometimes though I feel like if I walked away from a problem more I would be more productive than locking horns with it for hours. Productivity is complicated. Sometimes working less is more, sometimes working more is more. Effort only contributes to productivity if it yields a return so putting 8 hours a day of solid effort going the wrong direction is worse than 2 hours a day of productive work.We like to believe we aren’t making things worse, but sometimes we are. If you can do that less, you’ll be better without putting in more hours.

                              1. 2

                                Sometimes I feel like we lie to ourselves about making things worse because what would people think if they knew. Self deception as saving face.

                              1. 3

                                Sorry for the low-content post, but this reminds me of my favorite markov chain, trained on the works of HP Lovecraft and the official Puppet documentation: https://thedoomthatcametopuppet.tumblr.com/page/19

                                1. 2

                                  This is great! It’s nice to have some short, entertaining content to read while waiting for tests to run or code to deploy.

                                1. 13

                                  The most important thing for me in finding meaningful jobs has been networking.

                                  Two of the three most meaningful jobs in my career (Human Genome Project for the Broad Institute and AWS where I work now) were both jobs I got because of my network. Be nice to people, make a point of being friendly and helpful, and horde contact information like a dragon hordes jewels. LinkedIn can be helpful for this.

                                  Also, I’ve found that not being picky about job titles can be incredibly helpful. After I spent the first part of my career as a Sysadmin (this is YEARS ago when that job still was a thing) a friend said “Hey, you can code Perl right? And you know a fair bit about UNIX? We have this release engineer opening” and that was the next 15 years of my life :)

                                  If you’re not money focused there are plenty of resources out there for jobs in the not for profit community like idealist. Good luck!

                                  1. 3

                                    I was waiting for you to show up in this thread. :)

                                    1. 1

                                      Thanks? I think? Not sure how to take that :) I care a lot about career issues - hiring, finding the right job, interviewing, and the like, and have thought about it all quite a bit through the years.

                                      If you think I’m off base or creating less signal than noise message me and I’ll try to do better.

                                      1. 2

                                        No, you’re good. I have just seen you post about how your career is meaningful before. Keep on keeping on.

                                    2. 2

                                      horde contact information like a dragon hordes jewels haha! Yeah friends from previous work and events is how I got my current work. I totally appreciate that.

                                      I think it is interesting that nonprofit has come up a few times. I think that seems like a shortcut to meaning, but I think people find meaning in building something that really communicates their ideas well. I am not sure. I don’t really have fully formed thoughts around that yet. Thank you!

                                    1. -2

                                      I don’t at all see what makes this ``dynamic’’. These same approaches could easily be used in a more static programming language. I don’t see the point the author is, apparently, trying to communicate.

                                      1. 16

                                        I didn’t invent the term and I agree it’s a confusing name. See this blog post for more details about the etymology: http://arcanesentiment.blogspot.com/2010/04/why-dynamic-programming.html?m=1

                                        1. 7

                                          “dynamic programming” as a term is older than lisp is.

                                          1. 5

                                            Some history on the name:

                                            An interesting question is, Where did the name, dynamic programming, come from? The 1950s were not good years for mathematical research. We had a very interesting gentleman in Washington named Wilson. He was Secretary of Defense, and he actually had a pathological fear and hatred of the word research. I’m not using the term lightly; I’m using it precisely. His face would suffuse, he would turn red, and he would get violent if people used the term research in his presence. You can imagine how he felt, then, about the term mathematical. The RAND Corporation was employed by the Air Force, and the Air Force had Wilson as its boss, essentially. Hence, I felt I had to do something to shield Wilson and the Air Force from the fact that I was really doing mathematics inside the RAND Corporation. What title, what name, could I choose? In the first place I was interested in planning, in decision making, in thinking. But planning, is not a good word for various reasons. I decided therefore to use the word “programming”. I wanted to get across the idea that this was dynamic, this was multistage, this was time-varying. I thought, let’s kill two birds with one stone. Let’s take a word that has an absolutely precise meaning, namely dynamic, in the classical physical sense. It also has a very interesting property as an adjective, and that is it’s impossible to use the word dynamic in a pejorative sense. Try thinking of some combination that will possibly give it a pejorative meaning. It’s impossible. Thus, I thought dynamic programming was a good name. It was something not even a Congressman could object to. So I used it as an umbrella for my activities.

                                            1. 7

                                              Comments like this are such a bummer. The ideas in this article are completely independent from any definition of the term “dynamic programming” and he provides a link to a well-known authority using the term in the same way. What the author is “trying to communicate” is well communicated, even if you are confused by the use of the term. Lobste.rs is not a place for this kind of snarkiness.

                                              1. 5

                                                It’s a fair criticism in that I should have talked about where the name comes from and that’s it’s confusing for me too.

                                              2. 2

                                                This has nothing to do with dynamic vs. static typing.

                                              1. 5

                                                After a few months of trying to find a terminal emulator that does what I want, and nothing more/less, I’ve given up my search and decided to ‘make’(0) my own using GNOME’s vte library.

                                                1. Not really making one from scratch, since vte seems fairly complete so it’s more a matter of just wiring up the functionality I want.
                                                1. 3

                                                  I’d be interested in reading a writeup of what you want and how existing terminal emulators fall short or otherwise miss the mark, if you were to write one.

                                                  1. 4

                                                    Here’s a quick list of must-haves:

                                                    • FOSS
                                                    • Stable
                                                    • 100% functionality from keyboard alone (I don’t care about mice)
                                                    • Ability to detect urls, show hints with key combo, and select url/run $BROWSER with key press
                                                    • Actual Wayland support
                                                    • Ability to set/change app_id in wayland compositors
                                                    • Proper unicode support
                                                    • Easily set colors in config file

                                                    To date, I’ve never found any terminal that meets all of those. After about 3 hours last night, I have a terminal I built which meets all but 1 (the url thing) of those must-haves.

                                                    I’ve tried everything from (u)rxvt, xfce-terminal, termite, st, alacritty, kitty (and a few others I cannot recall). Kitty was probably the closest to working however, because the developer does little/no testing on Wayland, it is fairly unstable.

                                                    1. 2

                                                      Easily set colors in config file

                                                      You can do that in almost any terminal.. using your shell config file: https://github.com/chriskempson/base16-shell

                                                      It baffles me that people still configure colors in terminal emulators’ own settings. This should be the only way to set colors :P

                                                      btw: https://github.com/myfreeweb/galacritty – lacks any mouse support whatsoever and any URL things (I just copy urls with tmux’s selection mode lol).

                                                      The thing with changing app_id, should it just be allowed at any time? Or should it be like the gnome-terminal “app wrapper” functionality?

                                                      1. 1

                                                        using your shell config file

                                                        I sometimes run other shells, so maintaining a bunch of configs for this would be annoying.

                                                        btw: https://github.com/myfreeweb/galacritty

                                                        Neat! I used alacritty and kitty for a while, but frankly they were both relatively unstable (probably each for different reasons). I think using the GPU for rendering a terminal is a bit overkill, since I rarely stream trillions of lines of text. Dumping dmesg is almost instantaneous for me using the thing I made with gnome’s VTE library (which always seems to come in last place in the ‘which terminal is the fastest’ contests…)

                                                        I just copy urls with tmux’s selection mode lol

                                                        Yea I may just do this.

                                                        The thing with changing app_id, should it just be allowed at any time?

                                                        When running the terminal. My WM allows moving applications to certain workspaces based on app_id, so if I run weechat in the terminal, for example, and want to start a terminal with a specific app_id that causes my WM to automatically move it to the correct workspace.

                                                        1. 1

                                                          maintaining a bunch of configs for this would be annoying

                                                          More annoying than configuring every terminal emulator on every machine? :)

                                                          It’s a regular script that uses escape sequences to set colors, you only have to tell shells that you start directly in the terminal to run it (if you e.g. always start with zsh, but sometimes run fish under zsh, you don’t have to configure fish at all).

                                                          want to start a terminal with a specific app_id

                                                          ah yeah, I see that you just have it as a command line argument, that’s easy.

                                                          Dumping dmesg is almost instantaneous

                                                          dmesg is usually not that long, try tree --dirsfirst -ChFL 5 in your home directory (twice, to let the FS cache everything for the first time). Or scrolling long files in vim.

                                                          1. 1

                                                            More annoying than configuring every terminal emulator on every machine? :)

                                                            I don’t usually have more than 1 terminal emulator installed, and my dot files are synchronized with stow/git, so I just configure it once, for everywhere.

                                                            try tree –dirsfirst -ChFL 5 in your home directory (twice, to let the FS cache everything for the first time)

                                                            Seems to average about 1.27 seconds over 5 runs (my ~/ is quite large). Given how rarely I would do something like that I’m willing to wait 1.3 seconds for it.

                                                      2. 1

                                                        Is the source available online?

                                                        1. 2

                                                          Yep, just posted what I have so far last night. Documentation is a bit lacking at the moment..

                                                          https://git.sr.ht/~craftyguy/terminate

                                                          I plan to add just a couple more things, clean up/refactor the source, and improve documentation a bit today/tomorrow.

                                                    2. 2

                                                      Have you tried mlterm? I like it a lot and it has very low latency compared to basically everything else.

                                                      1. 2
                                                        1. 2

                                                          Ah fair enough, wayland support is tricky.

                                                    1. 7

                                                      I think this is a bad idea because it’s worse for beginners. It’s also self-serving to the Twisted community that has felt spurned for a long time. We’re optimizing for the future Python programmers who will far out number us, and “batteries included” is the way to do that.

                                                      1. 3

                                                        Why is it self serving to the Twisted community?

                                                        1. 6

                                                          Because they want asyncio removed from the standard library because it competes with Twisted. Some more context here: http://pyfound.blogspot.com/2019/05/amber-brown-batteries-included-but.html

                                                          1. 3

                                                            Because they want asyncio removed from the standard library because it competes with Twisted.

                                                            I think that’s a very uncharitable reading of the situation. The suggestion is that much of the standard library become third-party on PyPI, not that the modules be eliminated altogether. And the reasoning is pretty sound: it’s an absolute pain to know that something was just added to the Python standard library but you can’t use it because it’ll be at least half a decade until enough users have migrated to a version of Python that has it. If the modules were on PyPI, you’d just tweak the version in your own dependency declaration and be able to rely on it same-day.

                                                            1. 1

                                                              Your comment doesn’t make sense to me. Can you clarify? Is “half a decade” a reference to Python 3? There were backports to 2 (https://pypi.org/project/trollius/). Yield from wasn’t in Python until 3.3, and there was a separate package for that version (https://pypi.org/project/asyncio/). What makes asyncio feel good is async and await which didn’t arrive until 3.5, and that’s syntax that you can’t install as a module.

                                                              We’re trying to optimize for new programmers, and the last thing they should be learning about is package management. It’s hard enough to just learn the language and become productive.

                                                              1. 1

                                                                A given Python release series (like 3.7.x) tends to have a support lifetime of around five years from the Python core team. And your installed base as an application developer is going to include a lot of corporate users who standardize on a version and ride it until upstream support ends (or even longer). Since you can’t count on people doing timely upgrades of their Python interpreter + stdlib, you can’t count on them being able to use anything that depends on more recent Python features.

                                                                We’re trying to optimize for new programmers, and the last thing they should be learning about is package management.

                                                                Unless you’re giving them a custom distribution of Python that also includes Flask, Django, the full numpy/scipy stack, Jupyter, ML/AI libraries and game toolkits in a single install, they’re going to have to learn how to type pip install at some point in order to be productive beyond the intro to the language.

                                                                And being a consumer of Python packages is not particularly difficult these days, because it really is just pip install. The variation in toolchains and techniques is almost all on the producer side of packaging, and is mostly invisible to people who just want to install and use unless we scare them off by inaccurately telling them there are dozens of competing options.

                                                                1. 2

                                                                  I think you’re conflating corporate users of Python with beginners. The point here is that we’re trying to delay the need to install any extra Python packages for as long as possible to maximize proficiency before users have to learn a second tool (pip in this case). If the standard library is empty then beginners have two problems to confront in order to learn the language. It’s a really simple concept.

                                                                  1. 1

                                                                    Nobody’s saying there should be no standard library. Several people are suggesting a much smaller standard library that contains only the really essential things, and move the rest to PyPI.

                                                                    You can still teach beginners how to write functions and classes and do things with just the language itself and zero import statements. And like I said, at some point if they want to write anything non-trivial either you need to be providing a bundled installer that has extra stuff in it, or they need to learn to run pip install.

                                                                    1. 1

                                                                      os, io, pdb, unittest, functools.wraps, collections, socket, … – all of these should be in PyPI? My advice would be to switch to JavaScript and npm if that’s what you want. With Python: “There should be one– and preferably only one –obvious way to do it.”

                                                                      1. 2

                                                                        I keep telling you what people are actually proposing. You keep refusing to engage with that and instead setting up straw men you can knock down. So I’m not going to spend any more time on this.

                                                        2. 1

                                                          Are there links on how you are going about this?

                                                          1. 4

                                                            This post from one of the core devs covers it pretty well I think:

                                                            https://snarky.ca/why-python-3-exists/

                                                            1. 2

                                                              Thank you for the link. This did not cover anything about the standard library, but it was helpful to get the perspective on Python 3.

                                                              So expect Python 4 to not do anything more drastic than to remove maybe deprecated modules from the standard library.

                                                              When I got to this line it became clear to me that the Twisted community and Python core devs are talking past each other.

                                                              1. 2

                                                                There is now a draft PEP suggesting that Python deprecate and remove some of the “dead batteries” in the standard library. There’s no reason, in 2019, for every Python user on earth to devote bandwidth to download, and disk space to storing, copies of a module for working with the audio files from 1990s Sun workstations (to take one egregious example of something that’s in the standard library with no real right to be).

                                                        1. 12

                                                          Kernelization has its disadvantages.

                                                          Right now, Python is a terrific introduction language. It’s simple yet regular syntax makes it easy to teach, and the full-featured standard library provides much of what a new programmer could want. Maybe not the best and newest takes on various domains, but more than enough for a beginner with modest means. All this comes in a single package from python.org.

                                                          The article suggests that we “kernelize” Python by removing a default “user space” of standard libraries and move those libraries like pip to an installer model.

                                                          Teaching dependency management with pip and all its friends (venv? Peotry? Pipenv?) sounds fraught to me - and unfriendly to beginners when the ecosystem and best practices seem to be in such flux.

                                                          We might also see that change will fragment Python - like Linux - into a myriad of competing distributions. There are already Python “distros” like conda out there, but a kernelized Python almost necessitates that everyone pick a distro. One more extra burden of choice and burden of research for a newcomer.

                                                          This is a good take for technical experts (this crowd) but a poor one for learners and approachability. How much easier would Linux be to learn if there was Only One Way to do it?

                                                          1. 4

                                                            Agree 100%. One of Pythons greatest strengths is its decent standard library, and built in package manager:

                                                            https://docs.python.org/library/ensurepip

                                                            I am fine with slimming down standard library, but dont remove it. We dont want to turn Python into C, where the standard library has almost nothing. All it does it force novice users to create their own their own terrible solution, or send them hunting into a forest of thousands of packages. One of the biggest pain points for me with any language is finding something I consider “basic” not in the standard library, and trying to figure out what package to use. Dont put that hassle on the community.

                                                            Deciding where to draw the line is a hard problem yes, but the alternative of no standard library is worse.

                                                            1. 4

                                                              Maybe the answer is two tier: core and stdlib. Core could be a narrow subset of modules that make up the base of the language and stdlib could be bootstrapped off of core (i.e., stdlib is all python code written using core or other stdlib). It would make it much easier to port stdlib to other pythons.

                                                              Of course it would take rewriting stdlib in some subset of modules that are deemed core. Would take a lot of work I imagine.

                                                            2. 2

                                                              The article suggests that we “kernelize” Python by removing a default “user space” of standard libraries and move those libraries like pip to an installer model.

                                                              As I read it (and here I’m speaking with the benefit of knowing the author, and also knowing the author of the piece he refers to in the intro), the article is being deliberately hyperbolic in mentioning the Kondo approach. The actual suggestion is:

                                                              We need a “kernel” version of Python that contains only the most absolutely minimal library, so that all implementations can agree on a core baseline that gives you a “python”, and applications, even those that want to run on web browsers or microcontrollers, can simply state their additional requirements in terms of requirements.txt.

                                                              A baseline set of modules significantly smaller than the current Python standard library is a provocative idea, but not necessarily new or even particularly radical; as Glyph points out, Linux distributions have a history of breaking up Python’s standard library across multiple separate distro packages, and while it’s been an annoyance for people who maintain things that depend on the standard library being shipped whole, it also seemingly hasn’t killed Python’s growth and adoption. And standardizing the minimal subset that gets to be called a distribution of Python would go a long way toward reducing the headaches imposed by distros’ current fragmentation of the standard library.

                                                              Teaching dependency management with pip and all its friends (venv? Peotry? Pipenv?) sounds fraught to me - and unfriendly to beginners when the ecosystem and best practices seem to be in such flux.

                                                              This I think is a bit unfair as a criticism, because most of the variation in workflows is on the producer side of packaging, not the consumer side. Consumers of Python packages don’t need to know or care what toolchain someone used to produce those packages. The main split on the consumer side is between users of pip and users of conda, which is is really more of a split between sub-communities working in different problem domains (a rough and grossly oversimplified description might be: if you’re writing networked applications you’re probably a pip user; if you’re doing numeric/scientific computing you’re probably a conda user).

                                                              1. 1

                                                                Would a ‘satellite’ language, let’s call it PythonBare – be an ‘in-between’ option ? it will be part of standard python distro, but could also be distributed without the main ’big Python.

                                                                Just trying to draw analogies between BetterC (a subset of D) and this discussion. I think for purposes of D, to have a language with D syntax, that can directly leverage pre-installed C-libraries is a big deal.

                                                                Although, thinking about it, not sure, to be honest, if the above analogy/benefit extends to Python world – because ‘PythonBare’ still can only use python libraries.

                                                                On another hand if PythonBare could some how automagically import and leverage without any wrappers available C-libraries, then may be there is an advantage (similar to BetterC or Zig ).

                                                                1. 2

                                                                  From my relatively uninformed viewpoint, it sounds like both RPython or Cython might be a suitable starting point for your BarePython idea.

                                                                  RPython is a restricted set of Python that’s used to implement the PyPy JIT runtime. Not all methods are available, and things like interators are simplified.

                                                                  Cython is a compiles extension language that easily inter-operates with C and Python. It’s not clear to me if Cython can use Python stdlib imports.

                                                                2. 0

                                                                  It’s simple yet regular syntax makes it easy to teach

                                                                  I feel like this is becoming less and less true. Annotations are not particularly simple, how everything works together in Async is quite complicated actually (thats actually true for many things in Python), lots and lots of new syntax with only little use being introduced.

                                                                  Python seems to try to become everything for everyone but is not tackling the elephant in the room which is the terrible package management. As you say, better have a large stdlib of obsolete code than to refer beginners to the horror that are virtual environments and its managers. Which is sad, because node manages to get by with a rather small standard library since installing things using npm is feasible.

                                                                  I always felt that this whole easy_install, setuptools, pip, virtualenvwrapper, venv, pipenv, etc etc. stuff was only necessary because CPython has no good way of handling envirornments on its own so everybody just tries to get by with juggling PYTHONPATH. Implementing a better way of locating modules in CPython could make this pain go away.

                                                                  1. 3

                                                                    Actually, I like the reddit/r/AskHistorians take on reposts; For philosophical ideas such as this, there might always be new things to be thought about, and understood. So reposts should be OK.

                                                                    1. 3

                                                                      But this is 2 days later! Maybe let it marinate/stew a bit longer…

                                                                      1. 1

                                                                        Ah, you are right!

                                                                      2. 2

                                                                        Sorry, I wasn’t trying to say that it was a repost. I just remembered seeing Hillel in the comments arguing about the provenance of object oriented systems. Then two days later he has an article on his site. It seemed like the conversation sparked the article.

                                                                        1. 3

                                                                          Confirmed! I’ve wanted to do a post on the broader history of OOP, but seeing the mistakes in the Ovid piece get super popular inspired this off the cuff one.

                                                                    1. 14

                                                                      Thanks, I feel like a dick, now.

                                                                      On a serious note, that hit me right in the feels. I wouldn’t go as far as saying that I am overconfident, but I’m definitely a loudmouth, and tend to argue to exhaustion when I think I’m right.

                                                                      I’ve been working for a while in recognizing that I might be wrong and try to clearly communicate that I am open (and in fact, often hoping) to be proven wrong, but it’s a process, and I can’t help but wonder how often have I just been a massive dick and prevented other people from even throwing an idea =(

                                                                      1. 8

                                                                        I’m almost exactly the opposite. I realize that usually my preferences boil down to: “I like this way because I’m used to it”, or “I don’t think it matters”. I used to be the most experienced C# programmer on my team. My teammates used to ask me questions like “Should I assign a type explicitly or just use ‘var’?” any I would say that that’s a personal preference and it doesn’t really matter. Another programmer with a much more pronounced opinion joined the team, and I noticed that people liked his answers a lot more. Sometimes people just like to be told what to do, especially when the consequences of the choices aren’t so clear.

                                                                        1. 5

                                                                          Sometimes people just like to be told what to do, especially when the consequences of the choices aren’t so clear.

                                                                          This, and also cases where the consequences on either side of a tradeoff are so minor, that the energy spent deliberating them out is costlier than just making a call and moving on. I spent far longer learning this, and fixing my behavior, than I wish I had.

                                                                          On so many of these low-impact-low-cost details, where I did not strongly care, where I could expect another senior to reasonably disagree (even just for reasons of “this is what I am used to instead”), I would give teammates a full-depth, longwinded explanation, only to end in an equivocation and let them decide. Maybe one out of a dozen times they learned something, but often I was wasting people’s time when they just wanted a boolean result from the ask_swifthand function.

                                                                          The first step in fixing this was realizing why I always led with longwinded explanations. It turned out to be misapplied empathy (which I assume-by-default that I lack, hence it took a while to realize).

                                                                          I personally value knowing the detailed ins-and-outs wherever possible, and so I saw extending a full explanation to another person as a sign of respect: share all the learning, and help them make their own decision. But when that comes by wasting their time (on a low-impact-low-cost choice), was not being perceived that way.

                                                                          Change was slow. I first changed my explanations to lead with the decision before launching into the explanation, giving a TL;DR to frame their expectation. After some time doing this, I began leading with the decision and then asking “There are reasons I could dive into, but they are subtle and inconsequential. So I’ll leave it there, unless you are curious?” followed by a long, awkward pause while I wait for an answer.

                                                                          Due to some personality quirks that pause is the hardest part for me, but it gets the job done. It balances respecting their time by giving them the option to walk away with my desire to extend a courtesy that I would (personally) value of learning more.

                                                                          Ironically, I do not always extend this sort of preemptive empathy to the rest of my life’s conversations. The last paragraph in the article really hit home, as I know friends and family often feel my SOLH is overconfidence layered with stubbornness.

                                                                          1. 3

                                                                            Sometimes people just like to be told what to do, especially when the consequences of the choices aren’t so clear.

                                                                            Newbies need to be fed opinions because they don’t have enough experience to have any of their own, and the ones they might have at the moment are more likely to be wrong than right. Like, yes, you can write thousand-line subroutines in Python, that’s certainly something the language allows, but more mature opinion will state that writing smaller subroutines is better for reasons of ease of modification a neophyte hasn’t run into yet.

                                                                            Gnomonic pronouncements make things go faster, but once the learner has some experience of their own, pushback is to be expected and should be encouraged. Except with things like styleguides. Those are completely arbitrary and set in stone for precisely that reason.

                                                                            So teachers need to have strong opinions because they can’t go over every single thing when they answer a single question, but those opinions must be held loosely enough that students can successfully challenge them as they gain enough knowledge to exercise their own agency.

                                                                            1. 2

                                                                              This is one thing that’s true: people like to be told what to do. People should be encouraged to think for themselves. The best of both worlds is perhaps by explaining the difference and explaining why you lean the way you do. That way you teach thought and give a straight answer.

                                                                            2. 5

                                                                              tend to argue to exhaustion

                                                                              that doesn’t sound “loosely held” :)

                                                                              1. 1

                                                                                I recently had an argument that went on for an hour until I conceded from frustration. Once we switched from the what to the how they immediately took to my original argument. Loosely held seems like it can be in the eye of the beholder.

                                                                                1. 1

                                                                                  Well, for some definition of loosely =P

                                                                                2. 3

                                                                                  I am open (and in fact, often hoping) to be proven wrong

                                                                                  Say that clearly and directly. Tell the other person that you are not feeling personally attacked and hope to be proven wrong.

                                                                                1. 16

                                                                                  “…The idea of strong opinions, loosely held is that you can make bombastic statements, and everyone should implicitly assume that you’ll happily change your mind in a heartbeat if new data suggests you are wrong…”

                                                                                  No, it does not. It means that as a professional, you do not associate your passion for a technical topic with your self-worth. It’s okay to feel strongly about something without being a jerk about it. It’s permission to speak honestly and get feedback from others. If you do this, others may very well call you an asshole! They may vote you off the island. So you learn what’s important and what’s not. What’s worth having public passion over and what’s just being a jerk.

                                                                                  You should have strong opinions about error handling, or customer service. You should speak up about your opinions so we might learn from you. You might have strong opinions about the pasta down at Luigis, but nobody cares. And we’ll tell you so. The requirement with strong opinions lightly held is that you have to agree to suck it up and do things you might not agree with. You can’t have one without the other.

                                                                                  It’s just the opposite of what this author thinks it is. It’s the thing that over time prevents people from being jerks, not encourages them to.

                                                                                  ADD: Does our industry have a problem with tech bros and people making bombastic statements? Most definitely. But I don’t think that’s related to SOLH. In fact, for every one of these bozos, I can show you five tech people that should be speaking up and are not. Those are the ones who cause real damage to an organization.

                                                                                  1. 21

                                                                                    You should have strong opinions about error handling, or customer service. You should speak up about your opinions so we might learn from you.

                                                                                    There is a famous Bertrand Russell quote: “The whole problem with the world is that fools and fanatics are always so certain of themselves, and wise people so full of doubts.”

                                                                                    It matches my experience exactly. The more I learn about complex topics like error handling or customer service, the more I realize that there is no “One True Way”™, and that it’s actually really complex and a series of trade-offs.

                                                                                    Does our industry have a problem with tech bros and people making bombastic statements? Most definitely. But I don’t think that’s related to SOLH. In fact, for every one of these bozos, I can show you five tech people that should be speaking up and are not. Those are the ones who cause real damage to an organization.

                                                                                    At least some people are not speaking up out of fear or exasperation by being told that their viewpoints are “absurd” or “not sane”.

                                                                                    I just tap out of discussions these days once someone starts acting like that, and I know that in a few instances it has caused real damage to the business. I’m not happy with that, but there is a limit to what I’m able to put up with before it starts affecting my mood to an unreasonable degree.

                                                                                    1. 7

                                                                                      Strong opinions does not necessarily mean obnoxious or loud. I don’t understand how we got to the point where people think that. I feel strongly about fishing in the rain. Doesn’t mean I ever yell about it. It’s an odd conflation of ideas, as if the demonstration is as important as the strength. I wouldn’t think that would be true at all.

                                                                                      We have to self-correct. In order to self-correct, it is necessary to make a case for some path we recommend and then negotiate/argue/arm-wrestle as part of a decision-making process. Passion allows us to make our case. It does not have to involve yelling or being rude. We just have to care, to feel strongly. After all, we’re professionals. Why wouldn’t we feel strongly about various parts of our job? I’d argue we aren’t worth a bucket of warm spit if we don’t. I know I wouldn’t want to work with anybody who had no passion in our work.

                                                                                      It’s such a weird confusion of ideas. Feeling strongly about something does not mean acting like a bozo. In fact, that’s pretty much acting childish.

                                                                                      Yep, everything is complex and people who oversimplify and are too sure of themselves can be problems. It is also true that given incomplete and sometimes self-contradictory information, we are required to make choices. We should do what we can to make sure these are the best choices possible. Tapping out ain’t cutting it.

                                                                                      1. 5

                                                                                        What you’re describing doesn’t sound like a “strong opinion” to me, but rather just “an opinion”.

                                                                                        Perhaps this is just a case of semantics, but the adjective “strong”, to me at least, means either “not likely to be convinced otherwise” or “obnoxious or loud” These are indeed two very different things, but generally neither of them are very constructive, and doesn’t really seem like what you’re describing.

                                                                                        1. 1

                                                                                          I thought the strong was an adjective on your belief in the opinion. As in, you believe with all your heart that a particular option/action/way is the right one.

                                                                                          1. 1

                                                                                            If you’ve got extremely strongly-held priors, you’re liable to be hard to convince (and require a lot of evidence to budge). This is a problem because such priors are not typically based on reality. As a general guideline, if you want to be more right about things, you ought to be less sure about them.

                                                                                      2. 2

                                                                                        I agree. I am not going to have a shouting match with my coworkers. It’s not worth the aggravation.

                                                                                        1. 1

                                                                                          There is a famous Bertrand Russell quote: “The whole problem with the world is that fools and fanatics are always so certain of themselves, and wise people so full of doubts.”

                                                                                          Well, I am personally full of doubts. Still I would give some of this type of decision makers more credit. It is easy to criticize everything since nobody knows anything of relevance with certainty (or you wouldn’t need to argue about it). In a tech context (and many others), it is often more effective to go with one reasonable choice, stick with it and control doubt with overconfidence.

                                                                                          1. 1

                                                                                            I like the quote and agree on the spirit ( https://quoteinvestigator.com/2015/03/04/self-doubt/ ) but you are confusing strong opinions with overconfidence / inflated egos.

                                                                                          2. 2

                                                                                            There’s something valuable about SOLH, so long as the LH part is taken to mean both qualifying statements based on an honest and informed estimate of confidence & actually updating your priors. And, some folks who stand by SOLH (including, presumably, some of its popularizers) take it this way. I’ve seen too many folks who apply it in the way OP describes to believe that it isn’t being used as a justification for ultimately destructive behaviors, though, even if that application is based on a misunderstanding of what the original popularizers intended.

                                                                                            OP’s suggestion of annotating statements with confidence levels (which is popular in the rationalist community for blog posts, & seems to have come from Robert Anton Wilson, who recommended it along with e-prime for avoiding common patterns of miscommunication) is a good one, because it rewards accurate estimates of confidence, providing a road for careful folks to gain social status over pundits & blowhards by raising a useful metric above being loud and contrarian (which, unless it’s paired with careful thought, introspection, and a rigorous and accurate estimate of one’s own confidence levels, usually ends up being equivalent to being annoying and wrong).

                                                                                            Of course, this runs contrary to norms. We live in an environment where qualifiers are called ‘weasel words’ & no matter how much you signal your level of confidence, all those signals will be stripped away as you are judged on your conclusions as though your confidence were 100%. Furthermore, confidence is held in esteem before it can even be proven to be justified, so we cheer on demagoges for being bold as they lead us full speed ahead into obvious traps. In such an environment, people who can get away with avoiding being held to account are incentivized to sound very sure, and everybody else is incentivized to keep their mouths shut.

                                                                                            1. 3

                                                                                              I think all of us are missing the point when it comes to passion, confidence, truth, and so on.

                                                                                              These are language games. Most of what teams do are language games. Put another way, everybody wants to do a “good job”. The rest of what we do is trying to come to common agreement on what the phrase “good job” means.

                                                                                              The certainty number isn’t awful. It just misses the point of what we’re trying to do. As arp242 pointed out, things are complex. What we’re looking for is the simplest question we can agree on that’s important, testable, and that we disagree on the answer. That question might be something like “Switching to SONAR will result in 10% fewer bugs to production” (I can’t give you a good example because it varies widely depending on the circumstances.)

                                                                                              To get to that pivot question, we have to take strong opinions about fuzzy things, then work our way towards being more reasonable about absolute things. This is the job of being a smart person who creates technology. A user comes in and says “I hate this! Make it stop sucking so badly!” and we work towards testable chunks of code.

                                                                                              It’s perfectly fine to respond with “What do you mean this sucks? This is awesome!” This is the beginning of that back-and-forth. Checking out is not an option. You could try to go the percentage route but then you’re not working towards better definitions of terms. Instead taking a strong position and then following it up with something like “Which parts are sucky?” takes the game forward a step.

                                                                                              “I like X!” vs. “I hate X!” are fine places to start. There’s passion there. Now add some technique and flexibility. If everybody is appropriately apathetic, you are in stasis. Not a good place.

                                                                                              1. 3

                                                                                                That makes sense when the origin of the decision-making process is passion, and when nobody comes to the situation with a nuanced understanding. In most professional situations, neither of these are the case: developers are working on things they don’t care about for users who see the application as a necessary evil, and one or two folks in the group have 30 years of professional experience to everybody else’s three months (along with complex nuanced and experience-backed takes that simply can’t be boiled down to a slogan). Three junior devs shouting irrelevant preferences doesn’t help in this situation, and because their nuance-free takes are low-information, they can be repeated over and over (and thus gain control over the thinking of everybody else). The person with the best chance of designing a usable system gets shut out of the discussion, because when takes are optimized for hotness nobody wants to read an essay.

                                                                                                This notional experienced dev has a greater justification for confidence in their general position, but will necessarily express lower confidence in any individual element, because they have experienced instances that provide doubt. Meanwhile, the junior devs will be more confident because they have never been contradicted. This confidence is not representative of justified confidence.

                                                                                          1. 5

                                                                                            My rule of thumb: if it’s not in a VCS, it doesn’t exist.

                                                                                            1. 1

                                                                                              Honestly, this is the big reason why I like Docker. I don’t want to have to remember how to configure anything. Let the computer figure it out.

                                                                                            1. 10

                                                                                              This came out in 1996. It’s a good thing we learned all of these lessons and don’t do any of them anymore…

                                                                                              1. 14

                                                                                                Just some feedback on that README: all those animated GIFs would be a lot easier to read if they were just pain text:

                                                                                                $ some_command
                                                                                                output
                                                                                                
                                                                                                $ other_thing
                                                                                                more output
                                                                                                

                                                                                                It’s just really hard to follow with all the animation, and you can’t look at anything for more than what feels like half a second before the text disappears.

                                                                                                1. 7

                                                                                                  I’ll make the change. Thanks for the feedback.

                                                                                                  1. 5

                                                                                                    Yes. Animations and videos are never the way to go for answering your audience’s very first question of, “what the heck is this and why should I care?” If your README.me says “play this video to learn about FooBar”, you’ve already lost me as an interested user.

                                                                                                    1. 2

                                                                                                      Personally, I agree, but there are people who would rather watch a video.

                                                                                                      1. 3

                                                                                                        I am in the video camp, my compromise in the end was a single gif followed quickly by text, hopefully it keeps everyone happy now.

                                                                                                    2. 2

                                                                                                      Not to mention that they’re not accessible to people who use a screenreader.

                                                                                                      1. 2

                                                                                                        That is an excellent point that I had not considered. Hard to get out of your own bubble.

                                                                                                    1. 11

                                                                                                      This is why I respect Mozilla as a company. They voluntarily delete data and genuinely feel bad that they had to make their users enable telemetry for the fix. They care about privacy and an open Internet and imho struck a great balance of ideology with pragmatism (DRM is the only reason I have been able to keep my parents and wife still on Firefox). I still continue using Firefox for as long as their core values are not compromised.

                                                                                                      1. 1

                                                                                                        Caring means a lot these days.