1. 2

    It would be interesting to see a follow up to this study given that Rust was only in the second tier of all the energy/time/memory groupings. Rust has moved in the rankings a bit on the CLBG since this study was created so it things might be shuffled a bit.

    1. 2

      This paper was published by the group in early 2021: http://repositorium.uminho.pt/bitstream/1822/69044/1/paper.pdf. It includes new measurements and evaluations based on Rosetta Code (in addition to CLBG). According to the paper, the measurement results of both code sources are comparable. I made some additional evaluations based on the geometric mean of the time data normalized to C though and get a different order than the one in Table 4 of the paper, see http://software.rochus-keller.ch/Ranking_programming_languages_by_energy_efficiency_evaluation.ods. The paper seems to have used arithmetic instead of geometric means, which is questionable given http://ece.uprm.edu/~nayda/Courses/Icom5047F06/Papers/paper4.pdf.

      1. 1

        It seems like this is an extension of the previous paper. I’m not sure if they made any changes to the CLBG sections. Couple of tells:

        • both papers group Ruby with functional languages, but not with object oriented languages
        • the tables don’t seem to be changed (on casual inspection)

        Still, it is extended with Rosetta examples so this is interesting. Thanks for posting it!

    1. 5

      I haven’t used Haskell but it’s baffling to me that A) there are multiple proposals for breaking changes after all these years and B) they’re spread out across multiple releases! At least get all your breaking changes done at once so people can fix things and move on instead of this constant drip of breakage. Just looks really weird from the outside. Maybe it’s not so bad if you have more context.

      1. 6

        As a Haskell user, none of these changes are a big deal.


        Ongoing: Word8#

        Code will use less memory. This is probably a game changer for folks with a lot of ffi code to c, but otherwise this won’t affect most people.

        Upcoming: Remove Control.Monad.Trans.List

        I didn’t even know this existed. List is already a monad, so why would anybody ever import this?

        Upcoming: Remove Control.Monad.Trans.Error

        This module has had a big deprecation warning on it for like 3 years telling you to use ExceptT.

        Upcoming: Monomorphise Data.List

        Yeah, I thought it was weird these functions were polymorphic. This is a good change. Probably won’t break my code because I imported Foldable/Traversable when I wanted the polymorphic variants, but some people might have to change imports after this.

        Planned: forall becomes a keyword

        If you named your variables “forall” then you are in a tiny group of people affected by this.

        Planned: remove return from Monad

        Presumably the top level definition is still in the Prelude module, so no big deal. This only affects people who override it incorrectly and break the laws it obeys.

        Planned: remove mappend from Monoid

        Ditto. This only affects people who wanted to overload an optimized version, which probably isn’t common.

        Planned: remove (/=) from the the Eq class

        Ditto. This only affects people who override it incorrectly.

        Planned: disable StarIsType by default

        This disables a rarely used kind-level identifier which looks like an operator, but isn’t. Instead you use a readable identifier. That’s a good thing. It probably won’t affect much of my code.

        1. 3

          This.

          I get more breaking changes from template-haskell than from anywhere else in The Language or base.

        2. 3

          I feel like it’s nicer when you just handle breaking changes one by one over time. Python 3 was the “break everything at once” thing, where you just get hit with a deluge of things all at once.

          1. 2

            It kind of fits Haskell’s slogan of “avoid success at all costs”. It seems that the people behind Haskell prioritize the inherent purity of the language over stability. I actually sympathize with this way of thinking, but that is easy for me to say, as I am not using Haskell in any serious way.

            1. 1

              One of Haskell’s claims to fame is its ease of refactoring so this is really just showboating.

              “Hey, look it’s so easy to refactor in Haskell, we are going to break the language all the time.”

            1. 14

              there should be one and only one programming language for everything. That language is Nim.

              This attitude makes me inclined to avoid Nim. I want to use a language that’s honest about its limitations. If you believe that a general-purpose language can beat a specialized one at any task that’s extremely naive and reflects very poor judgement.

              Many of the other points just feel like stating the obvious. Using the word “zen” to refer to these ideas feels very disrespectful of Buddhists.

              1. 14

                I’m assuming that statement was tongue-in-cheek. But Nim does have a really broad range of uses, since it can compile to C or JS, has an interpreter for a large subset of itself, and has a very extensible syntax.

                The term “the Zen of ____” has become a trope since the 1960s — try googling it — and has nothing to do with Zen Buddhism. You might as well say an article called “The Ten Commandments of functional programming” is disrespectful to Christians/Jews/Muslims.

                1. 8

                  Respectfully, old tropes can still be - and in fact are probably more likely to be - racist or appropriative, and should be reevaluated occasionally.

                2. 10

                  Using the word “zen” to refer to these ideas feels very disrespectful of Buddhists.

                  I’ve studied Zen Buddhism a bit and my understanding is that they’re generally far from the snowflakes you picture them here to be. It could be said that you’re probably being more disrespectful of them by saying that.

                  1. 2

                    “Snowflakes”? Can you explain? I’ve only ever heard it used by ultra-conservatives as an (unintentionally ironic) insult so I’m confused by the usage here, thanks

                    1. 3

                      Perhaps a cultural difference. It’s used where I live without too much political baggage. It refers to a person who gets offended without a reason. Zen Buddhists typically are not like that although there are individual differences obviously.

                      I think it’s a pretty clear metaphor though, I’m confused what you’re confused about.

                  2. 4

                    Using the word “zen” to refer to these ideas feels very disrespectful of Buddhists.

                    I’m not a Buddhist, but from what I have read about Chan Buddhist monks (from which Zen is descended) they were a pretty iconoclastic bunch. I imagine that some might have more of an issue with expounding a series of formalisms than with the appropriation of a term. My understanding is that they believed that enlightenment came from a sudden moment of clarity, not necessarily sustained study, and they tried to induce that moment of insight through koans as well as suddenly shouting or striking a pupil.

                    Whats more, there are some great koans about not letting things get to you. I like this one in particular:

                    Tanzan and Ekido were once traveling together down a muddy road. A heavy rain was still falling.

                    Coming around a bend, they met a lovely girl in a silk kimono and sash, unable to cross the intersection.

                    “Come on, girl” said Tanzan at once. Lifting her in his arms, he carried her over the mud.

                    Ekido did not speak again until that night when they reached a lodging temple. Then he no longer could restrain himself. “We monks don’t go near females,” he told Tanzan, “especially not young and lovely ones. It is dangerous. Why did you do that?”

                    “I left the girl there,” said Tanzan. “Are you still carrying her?”

                    1. 3

                      I am a (largely) Zen Buddhist, and we’re used to the word being used for chocolate bars and shampoos and the like. ‘The Zen of Nim’ just makes me assume it’s a riff on Python; no problem.

                      Ironically, I’m more at pains to point out that what you posted above is not a koan; it’s a fun story, or parable, but it would never be used as a part of meditation practice and is of a considerably different flavor than actual koans.

                      1. 1

                        Fair enough. I picked it up from Ashida Kim’s site so it isn’t my original description.

                        ** Edit **

                        I’m actually going to back this up. The wikipedia page for koans says they are “a story, dialogue, question, or statement which is used in Zen practice to provoke the “great doubt” and to practice or test a student’s progress in Zen.” This isn’t the classic sound of one hand clapping or does a dog have a Buddha nature, but it does present a paradox: it is not the act touching a woman that is inimical to the monk’s path, but it’s the how the woman disturbs and occupies their thoughts.

                        1. 2

                          I mean, you can believe what you like, but koans are a specific corpus which have a specific function in Zen training. It’s not a structural characterization; there is a specific body of texts that are used as koans, and that story ain’t in it.

                          1. 1

                            I’m open to changing my mind about it. I just don’t feel like I’ve got a good reason to yet. There is one website the calls it a koan, a person that says it isn’t, and a definition that indicates that it could be. Rather than focusing on why this specifically isn’t a koan, what should I be looking at for koans? You say that there is a specific body of texts, what are they called?

                    2. 4

                      I suspect they’re copying the Zen of Python. However your point is a good one, probably best to avoid the use of Zen at all in a programming context.

                      1. 11

                        I suspect they’re copying the Zen of Python.

                        Copying bad design is not good design.

                        But, of course, I kid.

                        1. 4

                          You kid and it’s actually funny! Even funnier if you know Python and the Zen of Python!

                          Truly a rarity in the tech sphere. If I could upvote this 20 times I would :)

                        2. 4

                          The computer science literature is full of “Bibles”. Do you find them equally disrespectful?

                          1. 3

                            I don’t actually find the usage of “Zen” disrespectful because I’m not a Zen buddhist.

                            I don’t have a problem with any of this, however I try to be respectful of things others find to be deeply important even if I cannot understand them.

                            1. 2

                              Yes, I guess I should have asked technomancy directly. Sorry for that :-)

                              But what I meant is that, like many other words, “Zen” is now used in everyday language, without its religious meaning. That might be sad, but I don’t think we should see any disrespect in that.

                            2. 3

                              I wouldn’t find this disrespectful if it were a list of aphorisms which seemed paradoxical or contained some subtle wisdom. These just don’t hit that mark. It feels like invoking the word “zen” is only done to make it sound more clever than it is.

                        1. 18

                          Hello Mike

                          1. 18

                            Hello Joe

                          1. 1

                            I adore this video.

                            1. 28

                              Fennel lead developer here.

                              I’ve posted about Fennel a few times in the past (https://lobste.rs/s/11p7mn/fennel_0_2_0_released https://lobste.rs/s/6bphbw/fennel_programming_language_rationale https://lobste.rs/s/hppjix/making_fennel_compiler_self_hosting_with) on this site for previous milestones and have had some great discussion ensue; feel free to ask me anything!

                              1. 4

                                Congratulations on the milestone! I’ve only shipped plain-old-lua so far, but I’ve been smiling as I watched Fennel get better for a while now. Nicely done. And I look forward to the game jam where using Fennel turns out to be a good idea for me :)

                                1. 4

                                  Thanks! Of course you can use Fennel for any game jam, but the big ones are the Lisp Game Jams held every April and October on itch.io: https://itch.io/jam/autumn-lisp-game-jam-2021 / https://itch.io/jam/spring-lisp-game-jam-2021

                                2. 2

                                  I was just talking to a friend of mine who is a game dev and used to use Lua a lot when he worked in cryengine. He complained about global variables in Lua and how Lua can return null values when a value isn’t present in a collection. I had brought up Fennel, but I wasn’t sure if it tackled either of those issues. I know that Fennel is semantically very similar to Lua. Does it provide any protections against either of those types of bugs?

                                  1. 7

                                    On global variables: in fennel, only names bound with (global ...) produce global variables, all other binding mechanisms (pattern matching, let, var, local) all produce local variables. Very hard to accidentally make a global variable :P

                                    On nil in tables, not directly. You’ll still get nil indexing into a table where there’s no value, but there is a macro like this: (?. tbl :foo :bar :baz) that will nil-check each index and short-circuit so you don’t accidentally index into nil, producing an error. You still have to nil-check individual indexing yourself though.

                                    1. 2

                                      Glad to hear that variables don’t default to globals!

                                    2. 2

                                      how Lua can return null values when a value isn’t present in a collection

                                      This is honestly kind of an odd complaint since it’s also true of nearly every other dynamic language out there. (Racket and Erlang being the main exceptions I know of.) Lua’s behavior (and thus Fennel’s too) is sublty different in that nil is much more consistently used to represent the absence of data, rather than other languages where you can have absurd situations like “I put nothing in this list and now the list is longer than it used to be”. In Fennel/Lua there is no difference between [] and [nil]. This takes some adjusting to if you are used to the other behavior but once you learn it, it’s a lot less error-prone.

                                      Fennel has a few advantages over Lua that make it easier to deal with nils when they do occur. The other comment mentions the nil-safe deep accessor macro ?. but there is also automatic nil-checks for function arguments with lambda as well as the fact that the pattern matching system defaults to including nil-checks in every pattern.

                                      1. 3

                                        This is honestly kind of an odd complaint since it’s also true of nearly every other dynamic language out there.

                                        They’re primarily working in statically typed languages (C++, C#) so it’s not totally a dig against Lua. Just normal workflow mismatch vs dynamically typed paradigm. Also, it was in the context of video game designers using scripting languages (e.g., Blueprint), getting out of their depth, and losing a couple days on bugs.

                                        (Racket and Erlang being the main exceptions I know of.)

                                        Python also throws when you try to access a value that isn’t present in a dictionary. Always reminds me of this blog post:

                                        I liken this to telling each language to go get some milk from the grocery store. Ruby goes to the store, finds no milk and returns no milk (nil). Python goes to the store, finds no milk and BURNS THE STORE TO THE GROUND (raises an exception)!


                                        In Fennel/Lua there is no difference between [] and [nil]. This takes some adjusting to if you are used to the other behavior but once you learn it, it’s a lot less error-prone.

                                        That is interesting! I didn’t know it did that.

                                        Thanks for taking the time to respond! I don’t really work in the video game space, but fennel seems like an interesting choice for video games. Piggy backing off of Lua for embedding in game engines and using macros to create DSLs seems like an interesting niche.

                                        E.g., I could imagine game designers editing rules in a minikanren DSL to affect changes in the game world.

                                        1. 3

                                          Haha; yeah can’t believe I forgot about Python. I listed Erlang and Racket there because they specifically do not even have a notion of nil/null in the entire language, whereas Python somehow manages to include null in their semantics, but not actually use it for this.

                                          I liken this to telling each language to go get some milk from the grocery store. Ruby goes to the store, finds no milk and returns no milk (nil). Python goes to the store, finds no milk and BURNS THE STORE TO THE GROUND (raises an exception)!

                                          On the other hand I’m actually somewhat sympathetic to this because nils are the most common type error in my experience by at least an order of magnitude, so I would characterize it differently. To me it’s more like you ask Ruby (or Clojure, or JS, or whatever) to go to the store to get some milk, it comes back, walks over to you, says “here’s what I got you”, holds out its empty hand, and drops nothing into your hand.

                                          If a human did that it would be considered extremely disrespectful or overly sarcastic! Throwing an exception is indeed an overreaction, but there needs to be some middle ground where you don’t just pretend that the operation was successful, and most dynamic languages simply don’t have the ability to convey this. https://blog.janestreet.com/making-something-out-of-nothing-or-why-none-is-better-than-nan-and-null/

                                          edit: the reason this works better in Erlang than other dynamic languages is that pattern matching is baked into the core of the language so it’s easy to represent success as a tuple of [ok, Value] which encourages you to match every time you have an operation which might in other languages return nil. Fennel has a pattern matching system which was in many ways inspired by Erlang.

                                          1. 2

                                            the reason this works better in Erlang than other dynamic languages is that pattern matching is baked into the core of the language so it’s easy to represent success as a tuple of [ok, Value] which encourages you to match every time you have an operation which might in other languages return nil. Fennel has a pattern matching system which was in many ways inspired by Erlang.

                                            That’s great to hear! I haven’t used Erlang, but I’ve used a bit of Elixir and I really love that design. Jose Valim described assertive code in an article a while back and I appreciate that perspective. That’s another reason why I like python burning down the store so to speak. Having the option to say “hey, I really mean it this time” is always useful.

                                            I once spent a day (or more?) tracking down a bug in a poorly tested Node JS codebase. It turns out that the SQL Server stored procedure was returning ID and the Node process was looking for Id. Of course, JavaScript will happily work with whatever you give it so it was a pain to find. The exception occured way further down the line. It’s hard not to get little bitter after an experience like that.

                                  1. 4

                                    Style note for the author: the code in here is almost impossible for me to read. Dark blues on black background.

                                    Edit: it’s been made easier to read now.

                                    1. 2

                                      I’m glad others pointed this out. Very distracting reading experience.

                                      1. 4

                                        I changed the code highlighting theme. (I am working on changing the website design too).

                                        1. 3

                                          That’s much better, thank you!

                                          1. 1

                                            While you’re at it, I’d suggest tweaking the font size and margins on mobile. The lines of text get uncomfortably short.

                                            1. 1

                                              I pushed a fix, let me know if it works for you.

                                        2. 1

                                          Yeah, I have to agree. Screenshot from my phone for reference:

                                          https://ibb.co/r5XxnzZ

                                        1. 3

                                          There are six different Rust stories on the lobste.rs feed today and now I want to write more Rust this weekend. Likely won’t, alas, since there are other tasks to work on.

                                          I will be finishing up Looptober! I’ve composed more music this last month than in perhaps the rest of my life combined. Finally putting all these Pocket Operators through their paces!

                                          Beyond that, I’ll enjoy some scary movies with my girlfriend in between giving out candy to the trick-or-treaters.

                                          1. 1

                                            What kind of music do you like to make?

                                            1. 2

                                              Just electronic music so far. Simple things with Pocket Operators this year.

                                          1. 10

                                            Aside: I wish we could banish the word ‘modern’ from software descriptions. It communicates next to nothing.

                                            1. 11

                                              Reminds me of how fish’s webpage still describes it as “Finally, a command line shell for the 90s” :)

                                              1. 13

                                                Fish started in the 2000’s, so I believe that’s a joke about the pace of UX advancement in text shells.

                                              2. 7

                                                Actually I find it useful when it’s used in the context of C++ libraries. The “modern library” tag suggests to me that it uses one of the newer C++ dialects, doesn’t use autotools, is more user-friendly, etc.

                                                1. 2

                                                  This is a pet peeve of mine as well. It strikes me as a weasel word. To me, a good sniff test would be to imagine reading a description of a utility from a 20 year old archive. Would the word “modern” help the reader understand the tool? Probably not.

                                                  1. 1

                                                    I can understand the technical idea. But for me it does make sense for archive formats (and looking at the date).

                                                  1. 1

                                                    Does anyone use Prolog ? Because I only know of this being taught in school, nothing in production. For Ada we know of at least one industry using it.

                                                    1. 5

                                                      There are few projects. For example: https://github.com/terminusdb/terminusdb

                                                      1. 2

                                                        Prolog is used in a log of linguistics and processing. I know of a couple of companies using it.

                                                        Fun fact: my only paper credit ever is a piece of Prolog code ;).

                                                        1. 2

                                                          Erlang was originally implemented in Prolog. The paper Use of Prolog for developing a new programming language (Armstrong, Virding, and Williams, 1992) is a short and fun read.

                                                          1. 1

                                                            Gerrit Code Review uses Prolog rules for allowing to customize rules (e.g. “What kind of Code-Review/Verified/… flags are needed, and by to whom, to allow a change to be submitted).

                                                            The verifier of pre-2014 SPARK (that Ada variant) was written in Prolog.

                                                            1. 1

                                                              I just found out about ProbLog, and this is supposedly built in ProbLog: http://bioinformatics.intec.ugent.be/phenetic/index.html#/index

                                                              1. 1

                                                                Tau prolog is used by the Yarn package manager.

                                                                1. 1

                                                                  I think it’ll become more and more important going forward. Mostly this is a safe bet since type systems are getting more important, but there’s a lot of other places where these ideas haven’t reached yet .. personally; I’d like to replace file systems with a logic programming engine.. and you also end up with a variant of logic programming if you only want to describe coordination free programs (which are a super important class of programs in the cloud world)

                                                                  1. 1

                                                                    Can you elaborate on what “coordination of free programs” means and how logic programming improves the situation there?

                                                                    1. 1

                                                                      The class of coordination-free distributed programs.. the programs that do not require coordination. Something like conflict free replicated datatypes for example (CRDTs).

                                                                      Edit: Logic programming enters the picture when you start talking about propagator networks; you can look at edward kmett talk about it or the keynote from popl this year.

                                                                  2. 1

                                                                    I use SWI Prolog for hobby stuff & a few little things in prod. There are a few companies that I know of which use it, to the extent that they’ve sponsored development of SWI and reached out for Prolog devs; in most cases though, the fact that they use Prolog is not advertised.

                                                                    1. 1

                                                                      More links to practical applications via here: https://lobste.rs/s/wdftoh/practical_application_prolog_1993

                                                                      My favourite is AusPig, an expert system for pig farming.

                                                                    1. 14

                                                                      This article would have gone down a lot smoother if it was a single sentence, “I like Common Lisp and I wish more languages adopted its model of image/repl-based development.”

                                                                      But of course, there’s an extra and implicit step here: the author has identified a certain set of the features of Common Lisp which they particularly like with Lisp itself and is thus tremendously upset that there are so many languages out there which claim to be Lisps but don’t have those features. The common sense response—maybe Common Lisp is very good at being Common Lisp and other Lisps are good at being other Lisps—is abandoned in favor of the conclusion that Common Lisp is good at being a Lisp and all other languages are bad at being a Lisp.

                                                                      I do wonder why this happens so much with Lisp. We’re constantly squabbling over whether something satisfies the criteria. The reference to Algol is instructive; while we might all agree that C++ is in the Algol family, we neither claim that it is an Algol, nor would we really care.

                                                                      I’m inclined to gesture vaguely towards Wittgenstein; Lisp is a useful category, probably more useful than Algol, because there is a family of languages which bear family resemblance to each other; each one shares some features with the others, though no two share exactly the same features. So it is a useful distinction. But we are as ever deeply uncomfortable with family relations. When we are presented with a category we insist on identifying the set of features shared by all its members. And we (perhaps very understandably) will start with that set that we, personally find most beneficial. So for the author it’s image development. For me it’s s-expressions, homoiconocity, and macros. And then we attempt to identify that set with the whole category, and become terribly agitated when there isn’t a good fit.

                                                                      1. 4

                                                                        I do wonder why this happens so much with Lisp.

                                                                        I also wonder about why this is the case with Common Lisp. My understanding is that there were a number of lisps and standardization was meant to unify them. Maybe to some people this standardization process means that it’s the heir to the throne and therefore the one true Lisp of lore. To me, it means the opposite: it’s yet another lisp.

                                                                        Am I missing something here?

                                                                        1. 7

                                                                          You’re right, I think the ‘smug lisp weenies’ generally come from that tradition rather than, say, the scheme one.

                                                                          If I had to guess I’d say it’s two things:

                                                                          1. Common Lisp comes out of the industrial tradition, as opposed to the academic or hobbyist one. Therefore its practitioners have had the greatest interest in identifying, honing and indexing on the best: the most powerful features, the most powerful libraries, the most powerful practices. Because they’ve had the greatest evolutionary pressure to actually produce good code, quickly (though probably not in large groups!)

                                                                          2. Given point 1, Common Lisp users for decades did have to constantly justify their choices, and for decades, many (more) of the things that made Common Lisp special were much rarer in industry. First class/higher order functions, lambdas, closures, memory safety, syntactic macros: all features which, like image based development, made Common Lisp special, but unlike image based development, were once exotic and are now commonplace. So in a way the greater Lisp family has won—those things (except for macros) are arguably all table stakes for any ‘modern’ language—but the Common Lisp community was forged in the heat of battle. Its discourse is still one predicated on the assumption that it’s a very special (as opposed to the current reality, which is that it’s simply rather special) paradigm, which requires constant justification and differentiation.

                                                                          1. 4

                                                                            The alternative explanation of course is that Common Lisp truly is unique and special, solely by its technical merits, and all other languages, including other Lisps, are Blub, and those of us who consider ourselves Lisp programmers but nevertheless fail to see that fact are the worst of the heretics, because we’re so close to the truth but still worshiping the wrong god.

                                                                            1. 5

                                                                              Cue that famous Emo Phlips skit about a person trying to talk someone off a ledge by trying to find common ground in religion.

                                                                              1. 3

                                                                                The narcissism of small differences, in other words. See also: academic politics.

                                                                                1. 3

                                                                                  academic politics

                                                                                  Well it’s Lisp so it’s on brand.

                                                                        1. 3

                                                                          Metroid Dread and maybe writing a blogpost about my experience with shorthand.

                                                                          1. 1

                                                                            Oh, damn! I didn’t know that it dropped. That’s kind of exciting.

                                                                            1. 1

                                                                              Can’t wait to play Dread myself (even if, technically, I plan to wait until after my weekend trip).

                                                                              1. 2

                                                                                It feels like Super Metroid in the best ways.

                                                                            1. 19

                                                                              Unfortunately, being nice won’t get you a lot of money in the modern corporate workplace.

                                                                              Being nice means some people will think you are a weakling.

                                                                              It’s really important to know how and when to be nice and how and when to be assertive (or whatever opposite is of nice is in this context…).

                                                                              For every “guide to being nice” there’s a career article in the vein of “how to get what you want: step 1. stop saying yes all the time”

                                                                              Just as different programming languages can be suited for different jobs. Different personality is suited for dealing with different incarnation of the corporation/society. A friendly personality is great for making friends. But that should not be your primary goal in a workplace.

                                                                              Developers who don’t have social skills and usually seem upset or angry.

                                                                              This has nothing to do with being nice. Telling people who don’t have social skills to ‘just be nice’ is like telling starving people to ‘just be rich’

                                                                              Developers who undermine each other at every turn.

                                                                              Necessary in many modern workplaces in order to compete for limited upward potential.

                                                                              Generally defensive developers.

                                                                              This has more to do with culture around mistakes. Not the fault of the individual.

                                                                              Developers who think that other departments of the company are stupid, that they don’t know what they want.

                                                                              They are stupid. At least for this limited domain. If you are a knowledge worker you rely on other people being stupid in your domain. So to assume that they are not would just not make any sense.

                                                                              1. 38

                                                                                I think a point of this blog post was to be polite when talking to and about your colleagues. Doing that does not imply in any way that you are a weakling. It makes the conversation better and you are more likely to come up with good solutions, in my experience.

                                                                                1. 9

                                                                                  My experience in the corporate workplace matches @LibertarianLlama’s’s post very much, albeit in a somewhat nuanced way (which I suspect is just a matter of how you present your ideas at the end of the day?).

                                                                                  For example, being polite when talking to and about your colleagues is important, primarily for reasons of basic human decency. (Also because “being professional” is very much a high-strung nerve game, where everyone tries to get the other to blink first and lose it but that, and how “professional” now means pretty much anything you want it to mean, is a whole other story.)

                                                                                  However, there are plenty of people who, for various reasons, will be able to be jerks without any kind of consequences (usually anyone who’s a manager and on good terms with either their manager, or someone who wants to undercut their manager). These people will take any good-faith attempt to keep things nice even in the face of unwarranted assholeness as a license to bring on the abuse. Being polite only makes things worse, and at that point you either step up your own asshole game, or – if that’s an option – you scramble for another job (which may or may not be worse, you never know…).

                                                                                  Also, all sorts of things, including this, can be taken as a sign of weakness under some circumstances. Promotions aren’t particularly affected by that. While plenty of incompetent people benefit from favoritism, everyone who’s in an authority position (and therefore also depends on other people’s work to move further up) needs at least some competent underlings in order to keep their job. So they will promote people they perceive as “smart” whether they are also perceived as “weak” or not. But it does affect how your ideas are treated and how much influence you can have. I’ve seen plenty of projects where “product owners” (their actual title varied but you get the point) trusted the advice of certain developers – some of them in different teams, or different departments altogether – to the point where they took various decisions against the advice of the lead developers in said projects,sometimes with disastrous consequences. It’s remarkably easy to have the boat drift against your commands, and then get stuck with the bill when it starts taking water.

                                                                                  Basically, I think all this stuff the blog post mentions works only in organisations where politeness, common sense etc. are the modus operandi throughout the hierarchy, or at least through enough layers of the hierarchy to matter. In most modern corporate workplaces, applying this advice will just make you look like that one weirdo who talks like a nerd.

                                                                                  (inb4: yes yes, I know your experience at {Microsoft|Google|Apple|Facebook|Amazon|Netflix|whatever} wasn’t like that at all. My experience at exactly one corporate workplace wasn’t like that either, but I knew plenty of people in other departments who were racking up therapy bills working for the same company. Also, my experience at pretty much all other corporate workplaces was exactly like that, and the only reason I didn’t rack up on therapy bills is that, while I hate playing office politics because it gets in the way of my programming time, if someone messes with me just to play office politics or to take it out on someone, I will absolutely leave that job and fuck them up and torch their corporate carcass in the process just for the fun of it).

                                                                                  Edit: I guess what I’m saying is, we all have a limited ability to be nice while working under pressure and all, and you shouldn’t waste it on people who will make a point of weaponizing it against you, even if it looks like the decent thing to do. Be nice but don’t be the office punching bag, that doesn’t do you any good.

                                                                                  1. 3

                                                                                    I mean, in the case you’re describing, I think it’s still valuable to act nice, like this post describes. You definitely gain more support and generate valuable rapport by being nice, rather than being an asshole. Oftentimes, being able to do something large that cuts across many orgs requires that you have contacts in those other orgs, and people are much more willing to work with you if you’re nice.

                                                                                    Nice should be the default. However, when you have to work with an asshole, I think it’s important to understand that the dynamic has changed and that you may need to interact with them differently from other coworkers. Maybe this means starting nice, seeing that they will exploit that, and then engaging far more firmly in the future. Maybe you start with trying to empathize with their position (I don’t mean saying something like “I see where you’re coming from and I feel blah blah,” but by speaking their language, “Yeah dude, this shit sucks, but we have to play ball” or whatever).

                                                                                    In general, the default should always be nice, but nice does not mean necessarily not being firm when it’s required (someone wants to explore a new technology, but your team is not staffed for it and you have other priorities that the team needs to meet), and nice does not mean you should put on social blinders and interact with everyone the same way. Part of social interaction is meeting people where they are.

                                                                                    1. 4

                                                                                      Nice should be the default.

                                                                                      Oh, yeah, no disagreement here. We have a word to describe people who aren’t nice by default and that word is “asshole”. You shouldn’t be an asshole. Some people are, and deserve to be treated as such. Whether they’re assholes because they just have a shit soul or they’re pre-emptively being nasty to everyone defensively, or for, um, libertarian reasons, makes very little difference IMHO.

                                                                                  2. 14

                                                                                    The benefits of being nice find no purchase in the libertarian’s mentality. Keep this in mind when you encounter them. Adjust your approach and expectations accordingly. More generally, try to practice what I call “impedance matching” with them (and with all people). What I mean by that is (1) understand their personality’s API and (2) customize your interface accordingly. Meet them where they are. Then there will be fewer internal reflections in your signaling. Of course, if they proudly undermine you, don’t think you can change them. You’ll have to just keep your chin up and route around that damage somehow.

                                                                                    1. 1

                                                                                      This corresponds to a very personal and painful lesson that I have recently learned. I would caution against stereotypes, but I’m a bit beaten down by the experience.

                                                                                  3. 30

                                                                                    Hard no. I’ve tried to be nice in my 35-year career (at least, never tried to undermine or hurt others) and have nevertheless accumulated what many would see a “a lot of money”. (And I’d have a lot more if I hadn’t kept selling Apple stock options as soon as they vested, in the ‘00s…) Plenty of “nice” co-workers have made out well too.

                                                                                    Telling people who don’t have social skills to ‘just be nice’ is like telling starving people to ‘just be rich’

                                                                                    The advice in that article is directly teaching social skills.

                                                                                    Necessary in many modern workplaces in order to compete for limited upward potential.

                                                                                    Funny, I’ve always used productivity, intelligence and social skills to compete. If one has to use nastiness, then either one is lacking in more positive attributes, or at least is in a seriously f’ed up workplace that should be escaped from ASAP.

                                                                                    1. 19

                                                                                      Unfortunately, being nice won’t get you a lot of money in the modern corporate workplace.

                                                                                      I’ve been at a workplace like yours but at my current one most of the most-senior and presumably best-paid folk are incredibly nice and I aspire and struggle to be like them. I’ve learned a lot trying to do so and frankly not being nicer is one of the things holding me back. Consider changing yourself or workplaces, I think you’ll be surprised. I’m disappointed by the “but I have to be an asshole” discourse here, part of growing up professionally for me was leaving that behind.

                                                                                      Unfortunately that version of me also wouldn’t have listened to this advice and would fall into this what’s with all the unnecessary verbosity? trap so I don’t know that this will actually land for anybody.

                                                                                      1. 9

                                                                                        I did not expect you to be a fan of the modern corporate workplace.

                                                                                        I recall one time at a former employer where I pissed off my managers by pointing out to an upper executive that it was illegal, under USA labor laws, to instruct employees to not discuss salaries. I was polite and nice, but I’m sure you can imagine that my managers did not consider my politeness to be beneficial given that I had caught them giving unlawful advice.

                                                                                        If you want to be assertive, learn when employers cannot retaliate against employees. I have written confident letters to CEOs, asking them to dissolve their PACs and stop interfering in democracy. This is safe because it is illegal for employers to directly retaliate; federal election laws protect such opinions.

                                                                                        It is true that such employers can find pretexts for dismissal later, but the truth is that I don’t want to be employed by folks who routinely break labor or election laws.

                                                                                        1. 12

                                                                                          It is true that such employers can find pretexts for dismissal later, but the truth is that I don’t want to be employed by folks who routinely break labor or election laws.

                                                                                          This is one of the best pieces of advice that a young tech worker can receive, and I want to second this a million times, and not just with regard to PACs and federal election laws. Just a few other examples:

                                                                                          • Don’t cope with a toxic workplace, leave and find a place where you won’t have to sacrifice 16 hours a day to make it through the other 8.
                                                                                          • Don’t “cope with difficult managers”, to quote one of the worst LinkedIn posts I’ve seen. Help them get their shit together (that’s basic human decency, yes, if they’re going through a tough patch and unwittingly taking it out on others, by all means lend a hand if you can) but if they don’t, leave the team, or leave the company and don’t sugar coat it in the exit interview (edit: but obviously be nice about it!). Let the higher-ups figure out how they’ll meet their quarterly objectives with nobody other than the “difficult managers” that nobody wants to work with and the developers who can’t find another job.
                                                                                          • Don’t tolerate shabby workplace health and safety conditions any more than companies tolerate shabby employee work.
                                                                                          • Don’t tolerate illegal workplace regulations and actions (including things like not discussing your salary) any more than companies tolerate employees’ illegal behaviour.

                                                                                          Everyone who drank the recruiting/HR Kool-Aid blabbers about missing opportunities when they hear this but it’s all bullshit, there are no opportunities worth taking in companies like these. Do you really think you’ll have a successful career building amazing things and get rich working in a company that can’t even get its people to not throw tantrums like a ten year-old – or, worse, rewards people who do? In a company that’s so screwed up that even people who don’t work there anymore have difficulty concentrating at work? In a company that will go to any lengths – including breaking the law! – to prevent you from negotiating a fair deal?

                                                                                          I mean yes, some people do get rich working for companies like these, but if you’re a smart, passionate programmer, why not get rich doing that instead of playing office politics? The sheer fact that there are more people getting treatment for anxiety and PTSD than people with senior management titles at these companies should be enough to realize that success in these places is a statistical anomaly, not something baked in their DNA.

                                                                                          Obviously, there are exceptions. By all means put up with all that if it pays your spouse’s cancer treatment or your mortgage or whatever. But don’t believe the people who tell you there’s no other way to success. It’s no coincidence that most of the people who tell you that are recruiters – people whose jobs literally depend on convincing other people to join their company, but have no means to enact substantial change so as to make that company more attractive.

                                                                                      1. 17

                                                                                        I am one of the folks working on this project, happy to answer questions. Note: This is a research project and the language is not yet finished to an MVP state, the compiler is not yet usable. The runtime is and we are using it in some other projects.

                                                                                        1. 4

                                                                                          Could you speak to this goal?

                                                                                          Can linear regions be used to remove the restrictions of per-object linearity without sacrificing memory management?

                                                                                          I had previously wondered whether allocating objects with mutual pointers (e.g., doubly linked list, graph, etc.) could be done with arenas in a language like Rust. I.e., when the last pointer to the arena is removed then the whole structure is deallocated. Is this goal a similar idea?

                                                                                          1. 12

                                                                                            That’s quite a broad question, so I’ll try:

                                                                                            The region abstraction in Verona defines a memory management policy per region. Each region is reachable from a single isolated (iso) pointer that points to the sentinel object in the region. All live objects in the region are dominated by (transitively reachable from) the sentinel. You can transfer ownership of iso pointers but only by a move operation. If an iso pointer is on the stack, the region that it refers to is deallocated when the pointer goes out of scope. If an iso pointer is in an object then the region is deallocated after the region that refers to it is deallocated. If an iso is owned by a concurrent owner (cown), one of the roots of a tree of regions, then it is deallocated when the cown’s reference count drops to zero. You can asynchronously schedule work to run with access to any arbitrary set of cowns that you have pointers to and scheduling work on a cown implicitly increments its reference count (in the abstract machine, at least).

                                                                                            The first region type that we implemented was a tracing GC. This is a lot simpler than most modern GCs because the single ownership property of the region guarantees no concurrent access (when you invoke the GC, you have exclusive ownership of the region, nothing else can be reading or writing it) so you don’t have to worry about concurrency. Because the region is not the whole of memory, this isn’t a stop-the-world thing, it’s just a block-the-caller thing - the rest of the system can continue executing happily. This allows arbitrary object graphs and will run finalisers on unreachable objects when the GC is invoked (explicitly) or when the region is deallocated. This kind of region is great for prototyping and lets you construct and collect arbitrary cyclic object graphs.

                                                                                            The second region that we implemented is an arena allocator that requests chunks of memory at a time and allocates with a simple pointer increment. This kind of region does not support object deallocation at all until the region is deallocated. Finalisers are run when the region is destroyed. This gives you fast allocation and deallocation for a group of objects with the same lifetime (e.g. things associated with handling a short-lived HTTP request).

                                                                                            We currently have an intern implementing a variety of different variations on reference counting within a region. Again, the region abstraction means that refcount manipulation can be cheap because it doesn’t need atomic operations and we can use all of the optimisations from the ‘80s that became unsound when threads were invented to do refcount elision. The simplest refcount policy is that objects in garbage cycles are leaked until the region is deallocated. If a data structure is potentially cyclic, but has a bounded lifetime, then this lets you optimise for the acyclic case. We can also use David F. Bacon’s refcounting + deferred cycle detection approach to collect a set of potential roots of garbage cycles (objects that are decref’d and not deallocated, and not incref’d while they’re in the possibly garbage buffer) and then scan those cycles to see if all refcounts are found by internal references and then deallocate the objects if they are. Or we can fall back to our tracing GC for cycle detection. All of these give different policies.

                                                                                            This lets us build DAGs and even cyclic data structures within a region, only requiring that regions themselves are arranged in a tree structure. Part of the motivation for this is that we have made a principled decision in Verona to not provide an unsafe escape hatch in the language. There are a small number of things that are intrinsically unsafe (scheduling, memory management, low-level I/O) because they are implementing and enforcing the type system and so can’t rely on the existence of the type system. Our goal is to allow everything else in fully type- and concurrency-safe code.

                                                                                            In contrast, Rust has a philosophy of asking developers to provide safe abstractions to unsafe code. In Rust, you can implement a doubly linked list in unsafe code and then expose safe interfaces. For simple things, I think this works, but my big worry about Rust is compositional correctness. If every crate that you use implements a data structure in unsafe code, and every single one is 100% safe when used with other safe Rust code, are they still safe when used together? Or do they opt out of safe mode in ways that are fine in isolation but are unsafe when used together?

                                                                                            The region model also provides a place in our abstract machine to fit untrusted C/C++ code into the system. Foreign code should not provide an unsafe escape hatch via the back door. There’s no point saying ‘use our safe programming language! Oh, of course, that 1,000,000 line C library that you want to use is completely unsafe and a single bug in that can violate all of the invariants that our safe language depends on’. In Verona, the plan is for every library to be instantiated (potentially multiple times) in a region. We have a prototype of this that uses separate processes and we can also support it with SFI or CHERI sandboxing (or with some non-process abstractions on a conventional MMU).

                                                                                            1. 2

                                                                                              my big worry about Rust is compositional correctness

                                                                                              In principle, the abstractions are 100% safe and composable. The abstraction layer is supposed to uphold all of Rust’s safety invariants, which ensures it can’t make any safe code unsafe, even if the safe code is incorrect.

                                                                                              Bugs can of course happen, and buggy unsafe code can break safety guarantees. But that’s more of a plain-old bug rather than unexpected compositional behavior. The rules compose safely, if you manage to follow them.

                                                                                              The rules themselves are conceptually simple to follow: no mutable aliasing, and basics of C/C++ memory safety. There are implementation gotchas. For Rust common ones are: unsafe code not defending from permissible-but-evil safe code (e.g. unsafe code is not supposed to trust custom iterators to report correct length), panic (exception) safety, and incorrect declarations of Send/Sync of the abstraction (see Rudra project).

                                                                                              1. 7

                                                                                                In principle, the abstractions are 100% safe and composable

                                                                                                That’s a big ‘In principle’. For example, std::mem::transmute points out in the documentation that it is ‘incredibly unsafe’ (emphasis theirs). There are lots of ways in which you could use this and end up with something that is safe in the presence of safe Rust code, but not safe in the presence of other unsafe code. Things like RC are similar: they violate the unique ownership rules, but in such a way that the borrow checker does the right thing in safe Rust, but where the set of things that you can do in unsafe Rust may violate the invariants that RC expects.

                                                                                                Each use of unsafe imposes some extra undocumented invariants that must hold for the use of unsafe to be correct. These are, by definition, rules that can’t be expressed in the Rust type system (if they could be, you wouldn’t need unsafe). You can locally enforce that these rules apply only in terms of the tools that the type system provides and in terms of your API.

                                                                                                One of the examples that came up in the Rust issue tracker, for example, was a proposed setjmp / longjmp crate and an async I/O crate. The latter depended on finalisers being run at the correct point for correctness, but an unsafe crate invoking longjmp would break this. Both are fine in isolation: the setjmp crate is fine if callers follow its rules and don’t depend on finalisers in frames between the setjmp and the longjmp. The async I/O crate was fine in isolation and mostly expressed its invariants in terms of conventional Rust behaviour. The two together ended up with something that doesn’t work and can violate memory safety (at which point all bets are off for all of your code).

                                                                                                There are rules, and if you follow them then you don’t end up with bugs, but that’s also true of C/C++. That’s not what I want from an infrastructure language that’s used for writing network-facing code that needs to provide strong security guarantees and five or more nines of uptime.

                                                                                                1. 1

                                                                                                  There are lots of ways in which you could use this and end up with something that is safe in the presence of safe Rust code, but not safe in the presence of other unsafe code.

                                                                                                  Rust is not a sandbox, so of course arbitrary buggy code can cause nasal demons anywhere. But when the abstraction around unsafe is not buggy, then it’s not going interact in sneaky non-composable ways with other code.

                                                                                                  Each use of unsafe imposes some extra undocumented invariants

                                                                                                  unsafe fn is free to require whatever it wants. However, once unsafety is wrapped in a safe fn, then it’s not allowed to impose any undocumented invariants on any code anywhere. Once you wrap something and say it’s a safe function, you play only by Rust’s rules, and they are enforced by Rust itself.

                                                                                                  If any two functions marked as “safe” could interact to cause memory unsafety, Rust considers this a bug in the function’s definition, not function’s usage.

                                                                                                  This is a big difference from C/C++ reasoning. A C library can say “don’t call this function on Wednesday”, and if you call it on Wednesday and it causes a buffer overflow, that’s your fault. In Rust it’s either unsafe fn, or it never ever causes buffer overflow, even if you call it all week. It may panic!("It's Wednesday, you dummy!"), but that’s not memory unsafety.

                                                                                                  BTW, setjmp and longjmp are unsafe fn and cause UB in Rust. Any use of them is invalid, and AFAIK you just can’t build any safe Rust abstraction around them.

                                                                                            2. 4

                                                                                              You can’t quite do that in Rust, but you can have nodes that reference others in an arena, and have their lifetime bounded by that of the arena. I think dodrio does this, but it might just use pointers: https://github.com/fitzgen/dodrio#design

                                                                                            3. 2

                                                                                              The FAQ section is pretty good, when you offered to answer questions – I wanted to make sure I do my leg work and see if my question was already answered, and surely it was in the FAQ Section (about why C++) :-) [1]

                                                                                              My other question, if you may talk about this – what would you envisage to be a ’ lay-man practical’ success outcome of the language. In other words what types of ‘typical business’ applications would then be possible, or easier to build, compared to the current state. Apologies in advance if this type of question is too open ended/ naïve.

                                                                                              [1] https://github.com/microsoft/verona/blob/master/docs/faq.md

                                                                                              1. 6

                                                                                                My other question, if you may talk about this – what would you envisage to be a ’ lay-man practical’ success outcome of the language.

                                                                                                I think it’s worth separating this into ‘success for the language’ and ‘success for the research project’. I’ll answer the second one first: I think there are two ways that the research project can succeed and two in which it can fail. It can fail because either the abstractions that we’re building don’t work (with the new version of the type system, I’m more confident that this won’t happen), or because they do work but they don’t provide sufficient advantages to drive adoption. I think the project can succeed either by producing a new language that has compelling advantage with respect to others or by discovering that we have a path to retrofitting those ideas onto other existing languages (for example, if Rust 4.0 adopts Verona’s core ideas).

                                                                                                In other words what types of ‘typical business’ applications would then be possible, or easier to build, compared to the current state. Apologies in advance if this type of question is too open ended/ naïve.

                                                                                                I have actually written a blog post about this, just not published it yet. We are describing Verona as an infrastructure language. To my mind, there’s a big gap between ‘systems languages’ and ‘application languages’ that doesn’t really have any good options in it.

                                                                                                A systems language needs to provide very low-level abstractions and to allow you to break the rules sometimes. You need a systems language to implement a scheduler or a memory manager because these are fundamentally components of any higher-level type system and so can’t depend on such a type system existing. C++ is a great language in this space. Rust seems to be competing quite solidly here too.

                                                                                                Application languages need to minimise the set of things that are not business logic that the developer needs to think about. For example, in C# (or Java, or Python) you have a global garbage collector because a bit of memory overhead or a bit of nondeterminism in tail latency is far less important than making the programmer think about ownership and object lifetimes for every object. Workloads in this space are often I/O-bound and so sequential perf doesn’t matter that much because even if you made the program take no CPU time at all it wouldn’t get much faster (and the bits that are CPU-performance critical are self-contained components that you can write in a different language and typically have an off-the-shelf building block for).

                                                                                                Infrastructure languages have a set of requirements that slightly overlap both of these. They need to be safe because they’re aimed at network-facing workloads that are going to be exposed to the public internet. A single security bug in the kinds of things that they target can cost millions of dollars. At the same time, they have strict resource (latency, memory overhead, downtime) constraints that also cost a lot of money if you violate. Programmers need to be able to reason about memory consumption and tail latency (which you can’t do easily in a world with global GC) because they have SLAs that cost money if they are not met.

                                                                                                The main targets at Microsoft (from my perspective, this is not in any way a plan - Verona is a research project and there are no product teams committed to using it) for an infrastructure language like Verona are the services that run on Azure. This would expose services to customer code written in application languages (TypeScript, .NET, whatever) where customers can focus on their business logic.

                                                                                              2. 1

                                                                                                I didn’t finish reading all the markdown notes but I described it to my friends as using a type system that looks a bit like tla+ I wonder if you’d agree with this characterization?

                                                                                                1. 4

                                                                                                  I was greatly excited when I first heard about TLA+ (via Hillel Wayne’s writings). I lost all interest when I realised that it was purely at the level of specification rather than implementation. Don’t get me wrong - that doesn’t detract from the usefulness or viability of TLA+ itself, it’s just a personal feeling. On that note, I would rather imagine that TLA+ would be comparable to theorem provers/solvers like Coq, Lean, Idris, Agda et al.

                                                                                                  1. 2

                                                                                                    Note: One of our interns proved some properties of the the Verona runtime’s scheduler with TLA+, but this is the closest that I’ve ever come to it and so I might be entirely wrong here:

                                                                                                    I think the comparison is both fairly accurate and somewhat misleading. Like any kind of concurrent specification language, Verona tries to provide a model of concurrency that is easy (or, at least, possible) to reason about and so it has an isolation and immutability type system that prevents data races. Unlike a specification language, a lot of the Verona type system relates to memory ownership and allocation. This is said from a position of almost complete ignorance of TLA+ though, perhaps if you can let me know the ways in which you think it’s similar then I can understand better whether this is the case?

                                                                                                    1. 1

                                                                                                      The intuition I have is that you use “in-degree 1” structures to encapsulate local things in nice ownership properties (like rust/pony) and then at the top you have the owners interacting and you use a tla+ style strategy to try all different interleavings and discover any hidden coordination in your logic… So I perceived this tla+ish testing strategy as the main novelty. Btw I like your framing of a “infrastructure language”

                                                                                                  2. 1

                                                                                                    FYI, the links to sample code are all broken — on the Explore page, under Concurrent Ownership.

                                                                                                    1. 1

                                                                                                      Thanks. The example code was all written against the interpreter, which was based on an older version of the language, so has all been moved to the deprecated directory. I’ll make a note to update the links and add some disclaimers.

                                                                                                  1. 5

                                                                                                    As an aside, I really love it. Sometime ago I wanted to bring in a greasemonkey script to load pushcx’s css and just never got it done. Super impressed and happy with the work that was done. Much appreciated.

                                                                                                    1. 9

                                                                                                      Thanks! (I did those PRs.) I like how dark mode turned out after revising it with everyone’s feedback, and I think following the OS theme via the media query is the best default behavior. Nonetheless, it was clear from the bikeshed thread that an override setting would make some people happier when using one of their favorite sites. I’m all for it.

                                                                                                      1. 3

                                                                                                        Thank you for your positivity and receptivity to feedback even in the face of criticism. :)

                                                                                                        1. 2

                                                                                                          The buck butthurt stops here.

                                                                                                    1. 7

                                                                                                      Does the pattern matching work with __subclasshook__? If so, I am looking forward to doing horrible horrible things with it

                                                                                                      EDIT: it totally does

                                                                                                      1. 2

                                                                                                        Please, hwayne… Have mercy!

                                                                                                        1. 5
                                                                                                          1. 2

                                                                                                            Hillel… No… We talked about this…

                                                                                                            1. 1

                                                                                                              This gives me strong ruby vibes :)

                                                                                                        1. 15

                                                                                                          Man, that reminds me of my first job out of college. I was an assistant at a legal technology company. One of the owners was an Israeli-American man and he asked me to pick up a sandwich from the Subway downstairs. He kept kosher and he specifically asked for no cheese. I asked him what bread he wanted and he said “whatever you are getting.” So I went downstairs and solemnly ordered the sandwich with an extra note that there should be no cheese on it since it was for a person who kept kosher. They asked what bread and I told them “the same as me: Italian Herbs and Cheese.”

                                                                                                          As soon as he looked at the sandwich he had a huge grin, ripped off the side of the bread with the cheese and ate the sandwich open faced. I felt like a huge dummy, but he told me not to worry. He was a pretty good guy.

                                                                                                          1. 7

                                                                                                            Being unemployed!

                                                                                                            New job starts Monday.

                                                                                                            1. 3

                                                                                                              Me too! My job starts the following Monday. Honestly, it feels really weird.

                                                                                                            1. 1

                                                                                                              Weird to go through all that without mentioning clojure.

                                                                                                              1. 1

                                                                                                                Maybe they don’t have clojure experience. Why would you have liked to see it added?

                                                                                                                1. 2

                                                                                                                  Its design philosophy is pretty specific about the limitations of OO for handling data and managing state transitions.

                                                                                                                  https://www.youtube.com/watch?v=-I-VpPMzG7c

                                                                                                                  1. 2

                                                                                                                    Clojure’s covered in a follow up article to a follow up article: https://www.tedinski.com/2018/03/06/more-on-the-expression-problem.html

                                                                                                                    1. 1

                                                                                                                      Thanks.

                                                                                                                1. 4

                                                                                                                  In before @hwayne pops up with a copy of Data and Reality.

                                                                                                                  1. 6

                                                                                                                    did someone say Data and Reality

                                                                                                                    tbf the op is using “data” differently than Kent did. Kent talks about data as a representation of the world in our system, Ted is talking about data as a category of programming values.

                                                                                                                    1. 5

                                                                                                                      You know you’ve been on lobste.rs too long when this is hilarious.