1. 12

    Clearly communicating really is a superpower.

    1. 12

      Sadly, it’s useless unless you’re talking to someone with the “Listening Attentively” Superpower.

      1. 5

        IME, if this is a problem, turning it around and asking the other person questions about what you’re discussing is a way to both get them engaged in the topic, and identify gaps in their understanding so you can work towards filling them.

        Not a perfect solution, of course, but questions are a powerful way to turn a passive listener into an engaged participant in the conversation.

        1. 2

          This is part of communicating. The idea that you can just spew out the perfect set of sounds and everybody “worth your time” will just grok you is a sure sign of being a shitty communicator.

          I’m a shitty communicator too, but at least I know it :)

      2. 7

        Actually, step 0 is patience.

        If somebody is overloaded or trying to do something or understand something…. Telling them what to do is useless. Your voice is just “Noise in their Head”.

        If they have a bee stuck in their bonnet… you can talk until you blue in the face, all you will do is frustrate everybody.

        Sometimes “Show, don’t Tell” will break the impasse.

        1. 5

          Yeah, I think this is the point of the blog post. Even if somebody has the “Listening Attentively” superpower, and even if they are calm, collected and think they are getting it, it is still sometimes nigh-on impossible to “just tell” them anything.

          1. 2

            Listening attentively also involves verifying what you’re hearing, repeating it back, in a sense, not just nodding your head. Truly listening well can effectively act as a parity check on the other persons’s ideas. Many folks don’t practice this sort of conversation, though, because it requires investing yourself in another person’s mental landscape, which isn’t often valued, outside of the therapy profession.

      1. 1

        Zola does seem opinionated, but it happens to align with what I’m looking for in a small personal site generator. Just switched over and I’m happy to be rid of a lot of hugo’s complexity.

        1. 3

          All work stuff unfortunately, but for good reason – I have a daughter being born any day now! Thankfully I work for an incredible employee-focused organization that gives me paternity leave, so my focus at the moment is making sure my outstanding work tasks have a nice bow on them before I go MIA for a little while.

          As for the work itself, mostly establishing a blue/green deploy process for our serverless application. It’s split into several services at this point (mostly because of CloudFormation resource limits), so there’s some custom orchestration we’re doing. It’s been fun to think through and implement.

          So yeah, working as quickly as I can. It’s a good kind of stress :)

          1. 6

            I’m continuing to work on increasing my productivity by implementing some basic systems. Last week was a huge success. I accomplished about twice as much as normal with roughly the same amount of effort.

            The new additions this week are:

            • A Filofax Saffiano A5 planner, which I have organized into a rough approximation of the GTD method.
            • A weekly planning session where I choose a primary project and distribute it’s tasks throughout the week. Previously, I was rather haphazard about choosing which task to work on, so projects tended to drag on with only occasional progress.

            My primary project for this week is to create a monthly budget with You Need A Budget.

            1. 4

              FWIW, You Need a Budget (YNAB) is great. Definitely give it a few months though. And be sure to connect it to your accounts (just like Mint, read-only, it’s safe). Yes, it is great to get into the habit of entering everything manually - and you have to for cash. But the online connection helps immensely if you forget something. I’m at 1.5 years now and the difference has been HUGE. My ability to budget before was terrible and YNAB has saved my butt. Budgeting used to be last minute - now I’m months ahead and finally saving.

              1. 3

                Also a huge fan of YNAB, been using it for just over a year now and it’s literally changed my life.

                However, I’d argue against linking your accounts. If there’s anything that I forget, I catch it in my weekly reconciliation process, which is yet another good habit to build (doing a weekly review of spending, adjusting budget categories, etc).

                To each their own I suppose! But the account linking just makes it slightly easier to not keep awareness of your transactions, which is against the point for my purposes.

            1. 4

              This is pretty one-sided. When it comes to building software (or anything for that matter), there’s both how we build that thing, and actually building the thing itself. Often how well we can build that thing or how well it can do whatever it’s job is is directly impacted by how we build it, which includes what tools and techniques we use to build it.

              It’s good for people out there to have this sort of attitude, because we need people on both sides of the equation, however, the way we build things and what those things are capable of advances because of the astronauts who are “wasting his time”. Those astronauts are who built the tools and patterns that let others just build the thing, and do so in a successful manner.

              I can see his side of the argument here. People who spend a lot of time thinking about abstractions and patterns may struggle to see direct application of those abstractions, which is why it’s good to have people who can take those abstractions and create useful products out of them. But to say those people are unproductive and wasting time is pretty insulting.

              1. 2

                The idea that abstractions are useless always reminds me of the haskell community (a popular community here on lobste.rs). Useless on purpose. Never trust something “useful”.

              1. 43

                One issue here that nobody else brought up is that the manager punished her for running the experiment, but didn’t stop her from running it. It seems to me that a better manager would have stopped her as soon as she proposed the idea and explained why he didn’t like it.

                1. 4

                  You might make a good manager :)

                  1. 3

                    Sounds too close to entrapment. Hard to make assumptions about the environment there, but that’s incredibly toxic.

                  1. 9

                    So, kind of the newer versions of Javascript has made this easier. That said, I think Node is not the best system to build a massive server web. I would use Go for that. And honestly, that’s the reason why I left Node. It was the realization that: oh, actually, this is not the best server-side system ever.

                    From the man himself.

                    1. 15

                      I hate when people use Ryans statements like this. It was the same when Ryan stopped working with Ruby and went to work on Node: suddenly people used that to say that Ruby is bad, because Ryan said so. I met Ryan multiple times at EuRuKo and spent many great lunches together and always saw him as a person that sees many facets to a thing. (BTW, these 5 or 6 long discussions are still some of the most important of my career, I was a student back then)

                      Ryan back then was interested in building async server systems. He started writing ebb in Ruby, just to realize that he’d have to move the whole Ruby ecosystem to async to make that work as cleanly as he’d like. That isn’t possible. Next came Node, which used a programming language that had no IO, so it had no blocking IO. It’s a genius move, if you have no interest in creating a programming language. For some reason, this thing had gaps, so there must be something new somewhere else.

                      Ryan - to my reading - is driven by very particular challenges that tease him. That’s great, and I learned a lot from him speaking about that. Note how he says “massive”. That’s a very narrow use-case. Most systems are not “massive”. I’m pretty sure, in inquired, Ryan would come up with a couple of hundred places where Node usage is fine.

                      1. 2

                        Nothing you’ve said here disagrees with that excerpt, though. The quote was Dahl saying “hey, this is not the best server-side system”. That allows for your observation of “a couple hundred places where Node usage is fine”.

                        It might also be instructive to note that Dahl also left Ruby–turns out, perhaps Ruby isn’t a good server language either. I think it’s reasonable to point out that the main benefit of the Rails ecosystem at this point will be legacy consulting work in ten years for those of us willing to put up with it.

                    1. 1

                      I’ve gone back and forth between taking digital notes (laptop and phone) and taking notes by hand, and currently I’m in the camp of notes by hand are the way to go. One of the primary reasons is what the author mentions about notifications. I would love to say I can control myself enough to not be pulled away, but that’s rarely the case.

                      Something about having a blank piece of paper and a pen focuses my mind enough to drill down into something with much more intention, whether that’s a meeting, or thinking through a problem.

                      1. 10

                        Interesting perspective, although the author seems to be dismissive of other people’s experiences. Having had a supportive environment from day 1, she then makes an appeal for people to stop being supportive to others who may not have had the same environment? And this based on the claim that some attempts at support are harmful, but how that’s harmful is not explained.

                        Also, “it’s not a problem in South India so it shouldn’t be a problem elsewhere” is not a very compelling argument. It seems he author has had a largely positive experience free of discrimination, and doesn’t understand people who have experienced bias. At the very end is an appeal to some kind of gender-blindness. Unfortunately that only works in environments that are already free of bias. In a biased environment, being blind to differences will lead to ignoring the existing bias.

                        Perhaps I would understand the author better if the points were more fleshed out, but as it is there are glaring gaps in this analysis.

                        1. 8

                          Maybe walking up to someone and saying “Oh I really wanted to listen in, because you are the only woman here” is sexist no matter what culture you’re from.

                          1. 2

                            I can definitely appreciate the argument that anti-intellectualism in America breeds the kind of high-school cheerleader/quarterback gender stereotypes that come back to bite all adults in their professional lives. (edit: grammar)

                            1. 1

                              I read this as another “here is my personal experience” post. It’s a nice reminder that as more effort is made to bring under-represented groups into the field we also need to be careful not to set lower expectations on those individuals as engineers or treat them differently than we would any other engineer. Things can be done with events and organizations in terms of pipeline and making sure groups are represented, but those individuals probably don’t want to be picked to speak or have an audience simply because of the color of their skin or their gender.

                              It’s a difficult balance to achieve, but that doesn’t make it any less worthwhile. This is a problem about people, so the only way to move forward is by understanding the people affected (and everyone else in the equation for that matter) to the furthest extent possible.

                              Edit: typo

                            1. 9

                              AdventOfCode!

                              OK, it’s only a small part of the week, but it is fun.

                              1. 2

                                Thanks for the reminder, I’d completely forgotten about it.

                                1. 3

                                  I’m in smug mode because today’s problem only took me 11 minutes. I would have been on the leaderboard if I’d actually got up at 5am!

                                  (We’ll gloss over the days that have taken me hours of head scratching :) )

                                  1. 1

                                    That leaderboard seems a bit silly. Perhaps they should be timing it from the moment that a particular user first loads the page, although that’s cheatable too.

                                    1. 1

                                      Yeah, there’s really no way to make it work that can’t be gamed. Personally, I’m happy to noodle about solving the puzzles without worrying about the leaderboard. Not getting up at 5am is something of an incentive…

                                2. 2

                                  I’m in the lead on my private leaderboard, so the pressure’s on to keep it!

                                  AoC is definitely one of my favorite things :)

                                  1. 2

                                    Having lots of fun with it myself too. Really getting to learn what D can do:

                                    http://inversethought.com/hg/aoc/file/tip/2017/

                                    1. 1

                                      Cool that you’re learning it since it doesn’t get much attention. I’d be interested in your impressions of it by the end on top of what language background you came from before D.

                                  1. 2

                                    I agree pretty whole-heartedly that a break up or some sort of regulation is needed to reign in the monopoly, but have yet to see a viable proposal for how that could happen. Anyone have some ideas on what it might look like?

                                    1. 5

                                      When this topic came up on HN about 6 months ago, someone suggested a solution that is sort of like how AT&T was dealt with in the 70s. They were required to let other companies use their copper. For the big tech companies that would mean requiring them to open up APIs and license them to all comers, provide access to social graphs, etc.

                                      1. 7

                                        In the case of Facebook, that’s about the last thing I want. We already have a limited version of that, where every other web site and service wants to link accounts. I refuse to do that, but it’s very obvious some of my friends have. It’s annoying as hell. I want the walls to be higher, much higher.

                                        1. 2

                                          maybe a better idea would be to force facebook to federate with e.g. gnu social and mastodon. so you can have competing services, rather than having one service which 90% of people must be members of in order to connect with the majority of others. linkedin is another one, where it forces people to subscribe to their service in order to get a job, and using an alternative network is not feasible because it’s a totally closed service.

                                    1. 3

                                      Surely the community can support archiving and hosting the existing content, right?

                                      1. 3

                                        The question with the archives seems to be who’ll own the copyright on them. If the company is bankrupt and ends up liquidated at auction, ownership may end up with one of those miscellaneous companies whose business model is buying up bankrupt companies’ IP and trying to squeeze money out of it. As @hobbes points out in a sibling comment you can actually buy a copy of the archives right now, but that doesn’t give you the copyright allowing you to host a publicly accessible copy.

                                      1. 2

                                        This is often the easiest thing to forget about the code I produce. Appreciate the reminder!

                                        1. 2

                                          I keep a little bit of bash in my .zshrc that gives me some cli commands for handling my notes, and stores it all in my ~/notes folder. Basically note subject will create ~/notes/{date}-subject.md, and note subject folder does ~/notes/folder/{date}-subject.md.

                                          journal aliases to note journal journal, so my daily journal entries all go in ~/notes/journal/{date}-journal.md. The nice thing is I can run that command and it will always open today’s entry. That way I can pop in, capture a thought, and then get back to work.

                                          For my work log I keep a file called ~/notes/DOING.md, and the command doing opens that. I delete stuff out of there as I go, which helps me not worry too much about formatting and all that, and just use it as a way to focus my thoughts through the problem I’m on.

                                          Works pretty well for me!

                                          1. 48

                                            The choice of name is hilarious.

                                            1. 30

                                              I particularly like that it is a implemented in Racket….

                                              I’m sure he can create some extensions like a Madoff package manager and a Ponzi operator and….

                                              1. 4

                                                Yes, this is golden: “Pyramid Scheme is implemented using the appropriately-named Racket.”

                                              2. 15

                                                Not to mention the book title: “Destabilizing Nation-states with Math: An Ethereum Hacker’s Handbook”. So good.

                                                1. 8
                                                2. 10

                                                  Totally brilliant. Combined with Racket, the name might be unbeatable.

                                                1. 4

                                                  It’s nice to see these kinds of posts. I had no clue how much work went into this new release (aside from the work on reducing memory usage they’ve done over the past several years – not sure if that is related or not though) and as if the noticeable improvements in speed weren’t enough, I’m even more impressed now after having read this post. Super smart move by Mozilla for sure.

                                                  1. 1

                                                    Agreed completely. These days I become more and more cynical that the big players have too much momentum for the smaller players to really make progress. But stories like these show that with the right idea, strategy, team, and dedication, awesome things can still happen. I’m rooting for you Mozilla! Thanks for the amazing browser :)

                                                  1. 6

                                                    Stack Overflow seems to try and solve two problems, and I think a single solution for both of them is causing some of the issue here. These two problems are:

                                                    1. Be a place for developers to ask questions and get some help.
                                                    2. Be a go to source of documentation for solutions to specific problems or explanations of concepts (kind of two separate things here too, but I digress).

                                                    As some other comments here have stated, the fact that all the “low-hanging fruit” has been claimed means that beginners that come to the site with some of these basic questions are downvoted and closed out due to the mod practices outlined in the article, even though SO is often promoted to newer devs as a great place to get help (maybe not so much anymore though, it seems).

                                                    The problem is one group (new users, non-expert devs) see the site as a “get help” tool, while another group are vehemently trying to curate the site as a source of documentation that has no place for “invalid” content.

                                                    StackOverflow’s documentation experiment seemed like a good way to optimize for the second use case, but clearly there were some issues there. Overall though, it seems like the functionality of the site needs to provide more streamlined UX for both of the use cases, instead of mashing it all together in one. Maybe that’s not the vision intended for Stack Overflow, but I see it as a cause of some of this friction at least.

                                                    1. 20

                                                      Thanks to all the Monad’s tutorial and hype, when I first learned Haskell, a few years ago, it took me a few months to accept that I had understood Monads at the first glance.

                                                      All those tutorials were just confusing. I was all thinking “what am I missing? it seem so simple! why nobody explains what I’m missing?”. I was missing nothing.

                                                      A Monad is simply a wrapper. You have a function to wrap a value (return) and a function that applies to the wrapped value another function that returns a different wrapped value (bind). That’s it.

                                                      1. 11

                                                        Completely agree with you!

                                                        See the eightfold path to monad satori from What I Wish I Knew When Learning Haskell:

                                                        1. Don’t read the monad tutorials.
                                                        2. No really, don’t read the monad tutorials.
                                                        3. Learn about Haskell types.
                                                        4. Learn what a typeclass is.
                                                        5. Read the Typeclassopedia.
                                                        6. Read the monad definitions.
                                                        7. Use monads in real code.
                                                        8. Don’t write monad-analogy tutorials.
                                                        1. 2

                                                          Thanks for this list. Someone on my team recently read and shared a “Monads are like Burritos” blog post. The post made several dubious analogies. The effect was that people felt like they understood Monads. In fact, they did not. This is worse than not understanding them and feeling like you don’t understand them.

                                                        2. 7

                                                          Seriously. People act like the concept is so complicated and it really isn’t. I definitely knew what monads were for a long time before all the elaborate metaphors muddled my understanding. So far I’ve gotten the most mileage by illustrating how to convert procedural code to “math style” single expression functions, and rolling from there.

                                                          1. 1

                                                            People correct me if I’m wrong because I’m not a Haskeller. I do keep reading these monad things and getting confused about it. One person told me it was basically just imperative programming in a functional language to make things happen in a certain order. I haven’t had anyone attempt to corroborate or refute that. Maybe just one. Your statement sounds similar.

                                                            It also reminds me of SSA form a little bit in how you describe it.

                                                            1. 15

                                                              I will corroborate that as a partial explanation. And it should remind you of SSA form, since it helps accomplish similar things. I think that’s a confusing place to start though, because people tend to ask why functional languages don’t just run things in a certain order anyway. And they do, take printNum( readNum() + 1 ), this will clearly read a number before trying to print the number.

                                                              Instead, assume we have a VM that only understands simple “math style” functions like:

                                                              f(x) = expression
                                                              

                                                              Such as:

                                                              square(x) = x * x
                                                              

                                                              So yes we could write:

                                                              main() = printNum( readNum() + 1 )
                                                              

                                                              But we could not write:

                                                              main() = print("multiple"); print("expressions"); print("in a sequence")
                                                              

                                                              That is, the VM does not implement multiple statements in a function, it expects only a single expression. Why not? Ignore that for now. This code will work though:

                                                              main() = printStage1()
                                                              printStage1() = printStage2(print("multiple"))
                                                              printStage2(x) = printStage3(print("expressions"))
                                                              printStage3(x) = print("in a sequence")
                                                              

                                                              See how that would work?

                                                              That’s tedious as hell to write though. Humor me, and now lets write it with lambda expressions. Lambda expressions are function values, i.e. these two definitions of main are equivalent:

                                                              main() = print("hello world")
                                                              main = λ() -> print("hello world")
                                                              

                                                              Notice I’m using main() = to define a named function, but just main = with lambda. This is exactly identical to the following javascript:

                                                              function main() { print("hello world"); }
                                                              main = function() { print("hello world"); }
                                                              

                                                              So we can rewrite our program like so:

                                                              main = printStage1
                                                              printStage1 = λ() -> printStage2(print("multiple"))
                                                              printStage2 = λ(_) -> printStage3(print("expressions"))
                                                              printStage3 = λ(_) -> print("in a sequence")
                                                              

                                                              Now lets inline some things, one step at a time:

                                                              main = λ() -> printStage2(print("multiple"))
                                                              printStage2 = λ(_) -> printStage3(print("expressions"))
                                                              printStage3 = λ(_) -> print("in a sequence")
                                                              
                                                              main = λ() ->
                                                                       (
                                                                         λ(_) -> printStage3(print("expressions"))
                                                                       )( print("multiple") )
                                                              printStage3 = λ(_) -> print("in a sequence")
                                                              
                                                              main = λ() ->
                                                                       (
                                                                         λ(_) ->
                                                                           (
                                                                             λ(_) -> print("in a sequence")
                                                                           )( print("expressions") )
                                                                       )( print("multiple") )
                                                              

                                                              We now have a strategy for compiling a sequence of expressions into a single lambda expression, that returns the result of the last expression. Notice that I used underscores for the lambda args, because their result was unused by the function. But what if our program uses variable names? These are equivalent:

                                                              main() = {
                                                                n = readNum();
                                                                printNum(n);
                                                              }
                                                              
                                                              main = λ() ->
                                                                       (
                                                                         λ(n) -> printNum(n)
                                                                       )( readNum() )
                                                              

                                                              Hopefully you can now see that we could write a compiler that converts normal imperative code with variable assignments and so on into an unreadable chain of simple lambdas.

                                                              So why would you want to do that? Well, if this was a language we were implementing, we can add imperative syntax to our language without actually extending the VM. Our language interpreter can pre-process the code into simple lambdas, then the VM only has to know how to execute simple lambdas. That’s neat.

                                                              It also lets us make radical simplifying assumptions, just like SSA. Function calls can be evaluated in any order, as long as all its arguments have been evaluated first, just like SSA. But the way we’ve done it so far makes every line dependent on every previous line. So now lets split = into = and <-, where = denotes a weakly ordered assignment, and <- denotes a strongly ordered assignment.

                                                              main() = {
                                                                a = 7
                                                                b = 2
                                                                x <- readNum()
                                                                y <- readNum()
                                                                _ <- printNum(a / x + b / y)
                                                              }
                                                              

                                                              We don’t actually need to create a new lambda until we hit a strong assignment. So this simple lambda code is equivalent:

                                                              main = λ() ->
                                                                       (
                                                                         λ(a, b, x) ->
                                                                           (
                                                                             λ(y) -> printNum(a / x + b / y)
                                                                           )( readNum() )
                                                                       )( 1, 2, readNum() )
                                                              

                                                              Okay but what if we screwed up and wrote this:

                                                              main() = {
                                                                a = 7
                                                                b = 2
                                                                x = readNum()
                                                                y = readNum()
                                                                printNum(a / x + b / y)
                                                              }
                                                              

                                                              Which would compile to this:

                                                              main = λ() ->
                                                                       (
                                                                         λ(a, b, x, y) -> printNum(a / x + b / y)
                                                                       )( 1, 2, readNum(), readNum() )
                                                              

                                                              If functions can be evaluated in any order, will x or y be read first? It’s undefined. Either readNum() call could run first. You shouldn’t be allowed to weakly order things like IO. That should be an error. One way to do that is to give readNum a type, that insists its return value must be strongly assigned. But readNum should also be ordered with respect to printNum, and anything else that does IO.

                                                              So lets define these functions with a special return type that says they are both IO:

                                                              readNum(): IO(Number)
                                                              printNum(n: Number): IO()
                                                              

                                                              This IO wrapper type must be strongly assigned, and the result of its assignment will be its inner type. That is, these are basically equivalent:

                                                              x: Number = 1
                                                              x: Number <- IO(1)
                                                              

                                                              That’s the IO monad.

                                                              The strong assignment operator <- is called bind. A monad’s bind function takes a function, and returns a new monad, that represents the result of applying the function to the monad’s inner value. Using our typed readNum and printNum, our program looks like this:

                                                              main() = {
                                                                a = 7
                                                                b = 2
                                                                readNum().bind(
                                                                  λ(x) -> readNum().bind(
                                                                    λ(y) -> printNum(a / x + b / y)))()
                                                              }
                                                              

                                                              If you’ve ever written node.js before, you might be thinking hey wait a minute, that’s just an IO callback! Honestly yeah, pretty much. But with strong typing and syntax sugar. We can write this:

                                                              x <- readNum()
                                                              y <- readNum()
                                                              printNum(x + y)
                                                              

                                                              But if we write this, it’s a type error:

                                                              x = readNum()
                                                              y = readNum()
                                                              printNum(x + y)
                                                              

                                                              Why? Because the + operator has the type signature Number + Number, not IO(Number) + IO(Number). Even if + was defined for IO(Number), printNum still takes a Number, not an IO(Number). The type system forces us to bind properly.

                                                              So now our VM (or compiler) can treat all assignments as weak, because we’ve implemented strong assignments on top of weak assignments and lambdas. Normally assuming all assignments are weak by default would make the language hugely error-prone to use. But the IO functions all return an IO monad, so the type system protects us. Constrast with a conventional imperative language, that must assume all assignments are strong unless it can prove otherwise.

                                                              Naturally the weak assignment strategy opens up a lot more opportunities for certain kinds of optimization. Haskell still hasn’t taken over the world though, cause there are a lot of other opportunities for optimization, like hand writing vectorized assembly. That kind of thing is harder to do in Haskell than e.g. C.

                                                              1. 3

                                                                That’s one of the ways Haskell uses monads, but IIRC (and I probably don’t RC), that’s driven more by Haskell’s lazy evaluation than a fundamental property of functional languages.

                                                                A more general use case of monads is the Maybe monad, which lets you control for nulls. If a function could return an integer or a null, you instead say its return value is Maybe Int. Then the type system can enforce that anything that calls that function handles both the integer case and the “null” case.

                                                                1. 2

                                                                  I do keep reading these monad things and getting confused about it.

                                                                  Monads are mathematical structures. They have nothing to do with computer programming whatsoever. In fact, monads are so ridiculously general compared to most other mathematical objects that there is no way they could serve a concrete purpose for non-mathematician standards. So the first thing monads are not is “something you use”.

                                                                  Theoretical computer scientists (read: mathematicians) discovered [0] that you can “give a semantics” to a higher-order [1] strict [2] language in which “types” are denoted by “objects in a category C”, and “a computation that produces a value of type B from a value of type A” is denoted by “an arrow A -> TB”, where T is “a strong monad over C”. The tl;dr of all this [3] is that monads are “something intrinsic to the very structure of the programming languages we use”, just like the Earth’s gravitational field is “something intrinsic to the very structure of the world we live in”. You don’t need a mathematical model for it to exist, although it is nice to have one for some purposes.

                                                                  However, Haskell is a lazy language, so it is intrinsically comonadic rather than monadic. (Again, [3].) And, while Haskellers like their lazy language overall, they also want the sequential structure of their effects to be more like what strict languages have, because lazy effectful computations are insanely hard to reason about. So you could say Haskellers have monads in their standard library because they don’t have it in their core language.

                                                                  I have made essentially the same point elsewhere.


                                                                  Footnotes:

                                                                  [0] As opposed to “created”, like operating systems, word processors or computer games are.

                                                                  [1] Having procedures as first-class values, e.g., Lisp, Python, Java, ML, Haskell.

                                                                  [2] Reducing arguments to a normal form before they are passed to a function, e.g., Lisp, Python, Java, ML, but not Haskell.

                                                                  [3] Lots of details omitted. It doesn’t really matter what any of this means anyway.

                                                                  1. 1

                                                                    Your distinction between “discovered” and “created” seems to presuppose Platonism, which is a rather contentious issue in the philosophy of mathematics. A Formalist would say that math is indeed created, and that while the implications of a mathematical system may not be known for a long time, math is still a product of a human mind.

                                                                    1. 1

                                                                      I’m by no means a Platonist. I’m just saying monads weren’t invented for this specific purpose. Noticing connections between seemingly unrelated mathematical theories happens all the time.

                                                              2. 6

                                                                Explaining monads to programmers is like explaining commutativity to accountants.

                                                                1. 4

                                                                  Yep. This is why I shifted to trying to teach people to understand the concept of data that obeys laws. That’s the real issue: they see “monad laws” and they freeze.

                                                                  1. 7

                                                                    Probably easier for statically typed OOP people to just hear interface. A monad is a kind of interface for some generic type with a constructor and an aggregate/flatmap where the returned generic is the same type as the input.

                                                                    I think most of the struggle in learning that its just a type with a bind and return is people worry about teaching the math behind it. This is a bad idea. If you’re going to teach math, teach math, and if you’re going to teach programming teach programming. You don’t need to understand the abstract backbone to understand that you can use this thing to manage side effects.

                                                                    1. 1

                                                                      What exactly is a nontrivial data structure, if not “data that obeys laws”?

                                                                    2. 3

                                                                      This, a million times over. When I learned about monads in university, the concept was simple and intuitive and I recall just “getting it.” A couple years ago I decided to learn Scala (after a decade of using imperative languages), and a lot of the tutorials made a big deal about monads and tried to explain them in the most obtuse manner, using all kinds of computer science terms and references. For a while I questioned whether I had actually ever understood monads.

                                                                      1. 1

                                                                        I’m in the process of learning Haskell myself right now and I feel myself slowly coming to this same conclusion. I think part of the reason they seemed complicated on the surface, for me at least, is due to how heavily they are used in so much Haskell code out there.

                                                                        Also because of the abstraction-driven nature of Haskell, I’m always aware that there’s (potentially) a lot happening behind a small operator or function so as a beginner I assume there’s a lot of magic happening that I just don’t understand yet. Couple that with terms for these concepts that are rooted in mathematics (and thus unfamiliar with your average dev, like myself) and you get a recipe for assuming there’s always more to understand.

                                                                        1. 1

                                                                          I think it really took this video for that to get across to me. This whole time I thought I was still missing something. It turns out I use Monads all the time!

                                                                        1. 16

                                                                          I was just getting into GTD with Emacs org mode when I discovered Bullet Journals: http://bulletjournal.com/

                                                                          With bullet journals, you keep everything in a small notebook in your pocket. It’s satisfyingly analogue, and less complex than GTD. I don’t do any of the fancy colouring or artistry. My journals are raw and scrawly, and don’t require batteries or a screen.

                                                                          For everyday tech notes and writing, I still use org mode. But my personal and work stuff is now all tracked through bullet journals: a small pocket-sized Leuchturm 1917 for personal stuff, and a lined Blueline record book for work. I’ve been doing it for four months now, and it’s pretty decent. I think it’s worth a look-in if you would like an easy system to start with.

                                                                          1. 5

                                                                            I can’t enough good things about tracking my work with a bullet journal. I’ve been at it for almost three years and really appreciate the monthly (or weekly, as desired/needed) culling of unnecessary tasks.

                                                                            1. 4

                                                                              I love the bullet journal approach, especially how it is specifically intended to be customized and improved upon. I discovered it about 3 months ago, and it’s the only productivity system I’ve ever used that I’ve managed to keep using for more than a couple of weeks.

                                                                              I personally use a dotted Moleskine notebook that is just small enough to stick in my back pocket so I can keep it with me everywhere I go.

                                                                              1. 2

                                                                                I use org-mode very heavily, but I don’t really like being tied to a computer 24/7. Given that you have experience with both, do you think there is a way to integrate Bullet Journals with org-mode? For now I have a pocket notebook that I will sometimes use to write lists of things that eventually just get transcribed to org-mode.

                                                                                1. 1

                                                                                  After about a week of using a bullet journal I think org-mode serves a different but complimentary purpose. I’m using bullet journal for daily life tasks like dentist appointment and weekend plans with friends; org-mode for software, anything I do on the computer etc.

                                                                                2. 2

                                                                                  Those who like bullet journals, but dislike the daily rewriting ritual / table of contents focus, should check out “final version perfected” by Mark Forster.

                                                                                  http://markforster.squarespace.com/blog/2015/5/21/the-final-version-perfected-fvp.html

                                                                                  This really helped me get out of a rut, and reboot my GTD workflow. Mind you, that happened in ~2012 or so, and only for a short period. I’m a full-time GTD person, and have been for a while. And i use org-mode and emacs to manage it.

                                                                                  1. 1

                                                                                    Been using a bullet journal here now for about 5 months, and absolutely agree! Mine’s not pocket sized, and I’ve recently teetered between using it for only work, or for work and other personal things. Seems to work best for just work, and I hadn’t thought of just getting another yet. Might give that a go!

                                                                                  1. 19

                                                                                    i bet i’ll be shunned for this:

                                                                                    shes really privileged:

                                                                                    • “blessed” with self confidence
                                                                                    • has enough money to travel. and i bet it wasn’t her money. sorry.
                                                                                    • she has the funds to decide that she does a “boot camp” in the USA, despite university is tuition free for her in sweden (or selected EU countries which don’t have fees).

                                                                                    edit: to clarify: she does deserve her success, but from my point of view she had it easier than many. most of the advice is common sense. i’m still not sure where to get the 4 hours for personal projects from if - as advised - i sleep enough. and being healthy at 19 is much more easy than being healthy if you are older.

                                                                                    1. 5

                                                                                      she does deserve her success, but from my point of view she had it easier than many. most of the advice is common sense. i’m still not sure where to get the 4 hours for personal projects from if

                                                                                      These all ring true even though I thought she was awesome. She’s attractive, confident, well-funded, and figured out how to work crowds by 16 IIRC article. Her results such as timing or number of recruiters calling her might in no way apply to the average person following her programming or career advice. However, she still had interesting things to say that they might learn from. Of the privileged people, she was also at least being helpful to others in one of her boastful moments. Plus, I give everyone digging into coding a little props for that, too, as a “Welcome to programming! You’re one of us!” sort of thing. :)

                                                                                      1. 5

                                                                                        This comment feels a little…something.

                                                                                        “blessed” with self confidence

                                                                                        Do we know this? Or has she simply figured out effective ways to put herself out there? There are plenty of highly productive people that battle mental disorders, in fact, their productivity may be a way to keep them at bay.

                                                                                        My point is to say we shouldn’t presume things by looking at a few attributes of a person’s life.

                                                                                        1. 2

                                                                                          Do we know this? Or has she simply figured out effective ways to put herself out there?

                                                                                          i guess “putting herself out there” took at least some confidence, more than many people have. maybe i could have picked my words more carefully.

                                                                                          There are plenty of highly productive people that battle mental disorders, in fact, their productivity may be a way to keep them at bay.

                                                                                          yes.

                                                                                          My point is to say we shouldn’t presume things by looking at a few attributes of a person’s life.

                                                                                          i wrote it because based on the article i got this feeling. for example:

                                                                                          I’ve always been very independent: I moved to another country by myself when I was 18, travelled a lot on my own during my teens, and have always been busy doing anything to improve my future. I’ve never felt pressured into doing stuff because society wanted me to, I’ve always done my own thing.

                                                                                          at last: why is it bad to say someone is self confident? i didn’t write egocentric ;) it’s a character trait that is usually viewed as a positive thing in our societies. one has it usually more easy if one is self confident.

                                                                                          1. 1

                                                                                            It isn’t bad to say someone is self-confident :)

                                                                                            My point was to not view these traits as immutable, or bestowed. I have little doubt this is a result of her working on said traits, rather than them being bestowed.

                                                                                        2. 3

                                                                                          Any advice you see posted online (or anywhere else for that matter) is only going to apply to some of those who read it, and it’s going to completely miss the point for many others. It’s nearly impossible to provide advice that’s useful to everyone who reads it. While it can be worthwhile to point out things like this that may have also played a role in her success, it doesn’t negate the other things.

                                                                                          1. 4

                                                                                            Most people on this forum had it better than 5/6ths of the world population. You’re really splitting hairs.

                                                                                            1. 1

                                                                                              i thought a discussion board is about splitting hairs? :)

                                                                                              Most people on this forum had it better than 5/6ths of the world population.

                                                                                              that’s just stating the obvious. the 1/6 part still has a large standard deviation.

                                                                                              1. 4

                                                                                                Sure, in a 7 billion population even the top percentile has a large spread of wealth. It’s always more fun to look up :)

                                                                                                What I was getting at is she is a first world girl without college education who started a technical career as a teen. Sure she didn’t have to walk to boot camp barefoot in the snow, but it’s uncommon enough in 2017 to be of notice.