1. 5

    The most interesting bit (to me) is buried at the end; the fact that someone is picking up Mike Pall’s design for a next-gen GC and implementing it is very promising. GC has been a weak spot of LuaJIT for a long time.

    1. 1

      For anyone using clojure professionally, do a lot of JVM issues crop up? I mean do clojure devs regularly experience the same kinds of pains Java devs do?

      I’ve never worked with a JVM based language except Java.

      1. 4

        I’ve been developing Clojure programs for quite a while and I wouldn’t say I have many problems with the JVM. There are some breaking changes when upgrading Java versions, but I wouldn’t say I get a lot of JVM issues. Clojure is a very flexible language, so you can easily express some kinds of things which would be awkward to express in Java.

        This is a good demonstration of how Clojure lets you explore Java APIs, which might be a good entry-point for your work?

        1. 4

          It was rock-solid until Java 9 where Oracle threw a lot of the compatibility guarantees out the window and started introducing breaking changes, none of which were actually beneficial to anyone using Clojure. (except maaaaybe compact strings?) Now they’ve ramped way up the pace of breaking; non-LTS releases go unsupported before anyone has a chance to try out their successor; it’s kinda nuts.

        1. 1

          Dunno how I feel about this. I don’t run NextCloud yet but I’ve been considering it, and my experiences running a Mastodon instance for a few months left me unwilling to try again. Maybe they’ve scaled the requirements, footprint and admin surfaces back to a sane level.

          1. 7

            Actually this is a ActivityPub implementation, not a Mastodon one, which actually makes this a little more interesting.

            By using the popular ActivityPub standard, Nextcloud users can subscribe to and share status updates with users in the so-called ‘fediverse’, an interconnected and decentralized network of independently operated servers!

            Mastodon is probably the best known implementation of ActivityPub protocol, but there are actually a bunch of federated applications based around ActivityPub. For example there is also:

            • PeerTube (YouTube-ish)
            • PixelFed (Flickr/imgur-ish)
            • Diaspora (Facebook-ish)

            One of the kind of cool things is that all of these applications are using the same federated publishing protocol, they can federate with each other. I can reply to a thread on PeerTube in Mastodon, and PeerTube will understand it as a reply and display it as such, or you can publish an album on PixelFed and I can see as a posted album in my Diaspora.

            1. 1

              I didn’t realize that Diaspora had joined the Fediverse! Good on them!

            2. 2

              running nextcloud is pretty easy with docker

              1. 2
                1. 1

                  Running it might be easy, administrating and keeping it running never is. This goes for pretty much every server software out there.

                2.  

                  I’ve been running NextCloud for years, mainly for the very robust calendar which also happens to have a great UI and stellar integration with other calendar clients (Lightning, Android calendar, iPhone calendar, etc.)

                  1. 1

                    The post doesn’t seem to say either way whether it’s a reskinned Mastodon server or an independent reimplementation, does it?

                    1. 2

                      Looking at the source code it looks like it’s a PHP backend like the rest of NextCloud with a Vue.js frontend

                      From a cursory inspection it doesn’t look like they’re running all the infra necessary to run a full Mastodon node.

                      I suspect but don’t know that you’re actually just using their app to federate from one of their instances they’re running behind the curtain, but again I have no bullet proof evidence on that.

                      1. 4

                        ActivityPub is an open standard with some lightweight implementations (Mastodon is not one of them). From my cursory look at the source, I think this is a full activitypub compatible server.

                      2. 1

                        No it doesn’t give much detail at all. If it’s a reskinned stock mastodon server, that’s a hefty chunk of infrastructure required to run the thing (PostgresSQL, Redis for Sidekiq, etc.) and a lot of under the hood complexity go wrong.

                        I have mad respect for Eugen and the work they’re doing, but if it is in fact a stock Mastodon server, I’m out. I’m not a Ruby on Rails hacker and don’t have time to become one, and my installation hosed itself pretty hard.

                        1. 1

                          There’s always Pleroma if you want lightweight ActivityPub.

                          1. 1

                            Pieroma is lightweight, but its upgrade story and to a lesser extent its installation story are … Putting it kindly, lightly sketched out :)

                            You have to want to become an Elixir/Phoenix hacker if you really want to run a Pieroma with confidence. Not that that’s a bad thing at all mind, but you should be aware of that before you sign up.

                            At least that was the case a few months ago when my Mastodon instance ate itself.

                    1. 1

                      This is great, but I had an almost visceral negative reaction when I saw it was hosted on Medium.

                      1. 8

                        “A computer of one’s own; brought to you by a computer of someone else”

                        1. 12

                          OK, so, I totally get this reaction, but I’m gonna pick on technomancy despite my mad respect for a bunch of what he does :)

                          This kind of reasoning is faulty. Tools are tools. Everyone has to make a cost / value judgement based on what makes sense for them not you.

                          I build and run infrastructure for a living. I’m pretty damn good at it. That said, I run my blog on Wordpress.com

                          Why, you might ask? Because I ran my own Wordpress instance for years, then a statically generated blog using Pelican (a fantastic Python based static site generator I can’t recommend enough)

                          And then, after a few years of that, I decided that running my own Blogging infrastructure Just Wasn’t Interesting any more. I’d learned all I could learn from doing so, I’d even developed a nice set of Chef cookbooks to manage the whole thing for me.

                          But ultimately, the static blogging experience didn’t work for me. So now I let someone else manage this particular problem for me for a pittance, and focus on actually doing what I want to do.

                          So can we please consider taking a step back before we criticize others for making decisions that make sense for them?

                          1. 1

                            Thanks for your comment.

                          2. 7

                            I’m sorry, but this was the platform/blog we could setup in such short notice.

                            1. 6

                              Please don’t apologize. Thank you for writing these articles. Don’t take this kind of feedback too personally, it’s the price we pay for having a community of insanely smart, talented people read what we write :)

                              1. 1

                                Hey, it’s your site; I don’t know anything about the audience you’re trying to reach beyond lobsters, so I can’t speak to the trade-offs. It’s just that the irony in the title was just too much for me to resist. =)

                                1. 3

                                  Should I host my blog out of my own physical machine to resist the irony…

                            2. 2

                              It reads fine with javascript and even CSS turned off (or if entirely unsupported by your web browser).

                              1. -2

                                Me too. I’m glad I’m not the only one who has that reaction.

                                1. 2

                                  As already replied to the other person, this was the platform/blog we could setup in such short notice. Thanks for understanding.

                              1. 5

                                Rich has said a lot of nonsense about type systems over the years, but I think “you should be able to change a function so that it returns an Option without modifying the callers” takes the cake. Really glad I didn’t watch that keynote.

                                1. 13

                                  He said that you should be able to modify a function so it can take an optional instead of a mandatory without modifying the callers. It’s a standard example of “weakening preconditions” that most languages support.

                                  1. 12

                                    He said you should be able to modify a function from returning an option to returning a guaranteed non-null value. You have it backwards.

                                    1. 6

                                      Ah, OK; I misread the first example. Still wrong, but not blindingly, searingly wrong.

                                      1. 7

                                        I’m not sure I see how it’s wrong. It’s a semantically equivalent change and a small user interface boon. Tagged unions are not the only way to do unions.

                                        1. 5

                                          How is it semantically equivalent? It seems to me the former is widening the possible domain of result values, whike the latter is restricting the possible domain of result values. The former is, in general, impossible to safely accommodate without checking all callers, while the latter might conceivably not require any changes in callers.

                                          1. 3

                                            The comment I was replying to said that the example was “still wrong”.

                                          2. 4

                                            You’ll notice that on lobste.rs a suggestion that type systems may not be as useful in general is often conveniently interpreted as simply being ignorant about type systems :-)

                                            1. 13

                                              We’re talking about someone who has a long and well-documented history of straw-mans on this topic. If it were someone other than Rich I’d probably cut them more slack.

                                      2. 1

                                        I think what he’s proposing for spec is pretty interesting, independent of his ideology regarding types. That starts around 30 minutes in.

                                      1. 4

                                        I hope they change the tag line: “Rust: The programming language that empowers everyone to become a systems programmer.”

                                        In my experience, “systems programmer” is used to mean “I write programs that are hard, so I can look down on people who do mere ‘scripting’ programming”

                                        1. 9

                                          I think Wikipedia sums it well:

                                          […] application programming aims to produce software which provides services to the user directly (e.g. word processor), whereas systems programming aims to produce software and software platforms which provide services to other software, are performance constrained, or both […]

                                          Source: https://en.wikipedia.org/wiki/System_programming

                                          1. 3

                                            I’ve just now realized that to me, “systems programming” is basically equivalent to “not having to care about unicode”.

                                            I really like this.

                                            1. 1

                                              So an alternative to find would not have to deal with filenames or directory names that contain Unicode?

                                              Or if you’re writing a database engine, you don’t have to support Unicode?

                                              I’m being a tiny bit sarcastic, but it’s also interesting to investigate the boundary between “user” and “systems” programming.

                                              Edit wording

                                              1. 1

                                                It’s certainly a matter of perspective to a large degree (one developer’s platform is another developer’s application), but from where I sit, yes, find, databases and such are definitely more in the “applications” direction.

                                                The “systems programming” I deal with consists of things like filesystems (please please please don’t shove unicode in there), block storage layers, thread scheduling, memory allocators, etc.

                                                1. 2

                                                  The “systems programming” I deal with consists of things like filesystems (please please please don’t shove unicode in there)

                                                  Hah, doesn’t one of the new macOS file systems do this? IIRC, they require valid UTF-8 and I think even do normalization. With that said, I am not knowledgeable about file systems, so I don’t actually know at which level of abstraction these rules are implemented.

                                                  Anyway, I love Unicode. A significant fraction of the work I’ve done in Rust land has involved Unicode in one form or another. But my area of interest is text search, so that makes sense. Whether that’s “systems” or not, I dunno. ¯\_(ツ)_/¯

                                                  1. 3

                                                    Hah, doesn’t one of the new macOS file systems do this?

                                                    I haven’t really been paying too much attention to Apple recently, though it certainly seems believable – their filesystems have been case-insensitive since time immemorial, so madness of that sort was already well-established there…

                                          2. 6

                                            I thought this was a really great description of both the ambiguity of the term and its origin.

                                            http://willcrichton.net/notes/systems-programming/

                                            1. 4

                                              Thanks for sharing. This article does a good job of exploring why this is such an ill-defined term. In particular I find the early pre-Osterhout definitions to make much more sense than the modern usage. His dichotomy really seems to have set the discourse back significantly.

                                              1. 1

                                                Huh, I thought the definitive treatise on the nature of systems programming was this.

                                              2. 6

                                                We’re not fully happy with the tag line currently and happily take suggestions. “systems programming” being a fuzzy term is one of the problems. The spirit is definitely what we want, but if someone were to find a better way to phrase it, I’d be very happy.

                                                1. 6

                                                  My translation of “systems programmer” is “we don’t do GUIs”. ;)

                                                  1. 3

                                                    Yet many GUIs outside of the web context are written in systems programming languages :)

                                                    1. 1

                                                      Sounds like rust alright.

                                                    2. 4

                                                      I like the spirit of the tagline. Systems programming is a real thing, it’s genuinely difficult to do correctly - and Rust is helping make that situation better, so that more people can write less buggy systems code.

                                                      1. 1

                                                        This is cynical, although sometimes true.

                                                        1. -6

                                                          Systems programming is genuinely difficult in a way that, frankly, GUI programming just isn’t.

                                                          1. 10

                                                            If you just switch “GUI programming” and “Systems Programming”, this statement checks out, too. Modern GUI programming with backends and networks is a complexity beast. Add translation and such on top and it becomes incredibly hard.

                                                          1. 36

                                                            Such irony in the title here–“open source” is not about you; it’s a movement to hijack the free software movement and turn it into something a company can profit from, riding on free software goodwill and stripping the political aspects that are hard to reconcile with shameless capitalism.

                                                            I don’t think it’s what Rich meant here, but it does nicely serve to underscore the vast gulf between the oss and free software camps; if you are in software because you want to make the world a better place, move right along.

                                                            1. 25

                                                              it’s a movement to hijack the free software movement

                                                              There’s a problem with this statement, it doesn’t apply to me.

                                                              When I was open-sourcing my project I wasn’t joining any movement. I didn’t sign any contract. I use the words “open source” in a plain sense: this is a source code that someone can get and use according to the posted license. I’m totally fine with any company making profit off of this code. No company ever indoctrinated me into thinking this, and I deliberately chose BSD license over GPL exactly to not having to be associated with Free Software movement (I don’t hate it, I just didn’t want to). Yes, for real. People like me exist.

                                                              What I’m saying is, we already have a term meaning “open source + a particular ideology”. It’s Free Software. Please don’t try to appropriate “open source” to mean anything more than “available source code”. And no, I don’t really care what OSI thinks about this “term”. It’s their idea, not mine. I need some words to describe what I’m doing, too.

                                                              1. 9

                                                                When I was open-sourcing my project I wasn’t joining any movement

                                                                That’s exactly the difference between the “free software” movement and Open Source. You made @technomancy’s point for him.

                                                                1. 1

                                                                  It’s contradicting the framing that he’s somehow been duped out of believing in the fsf’s ideology by an open source movement.

                                                                2. 9

                                                                  P.S. In fact, there was a time when “Free Software” also wasn’t associated with not letting companies profit from it. Here’s a classic Mark Pilgrim on this: https://web.archive.org/web/20091102023737/http://diveintomark.org/archives/2009/10/19/the-point

                                                                  Part of choosing a Free license for your own work is accepting that people may use it in ways you disapprove of.

                                                                  1. 5

                                                                    Check Selling Free Software from 1996.

                                                                    1. 6

                                                                      I came here to share this link. the GPL, and free software, was never about gratis, was never about not paying for software. It has always been about liberty and the freedom to control one’s own software.

                                                                    2. 3

                                                                      2009 is classic? Am I old?

                                                                      1. 1

                                                                        “Classic” in a sense “explains well”, has nothing to do with being old :-)

                                                                    3. 5

                                                                      Just because you use a term doesn’t mean you get to define it. Saying “I don’t care what OSI thinks or why the term was invented” seems pretty strange to me… it’s their term and has a history, like it or not.

                                                                      1. 8

                                                                        What word should I use if I publish source code so people can use it but don’t care about furthering the cultural revolution?

                                                                        1. 5

                                                                          “Open source”.

                                                                          1. 1

                                                                            Billionaire. In a historical interview, that’s what the CEO of Apple believed he’d become if a lot of things lined up, one being getting a whole, networking stack for free from BSD developers. The other thing he envisions is them begging for money at some point so their projects don’t close down. He bragged his main competition would be contributing their fixes back since they got themselves stuck with la licence de la révolution. Attendees were skeptical about such a one-sided deal going down.

                                                                          2. 4

                                                                            No :-) The only way a natural languages is defined is through use, and the most common usage becomes a definition. OSI didn’t make this term theirs by simply publishing their definition, they just joined the game and have as much weight in it as every single user of the word.

                                                                            1. 4

                                                                              True, but also like it or not language evolves over time (always to the chagrin of many). This is not unique to technology or English. At the end of the day it doesn’t matter what either OSI or /u/isagalaev thinks, society at large makes the definitions.

                                                                              Having said that, if you step outside of the FOSS filter bubble, it seems pretty clear to me that society leans towards /u/isagalaev’s definition.

                                                                              1. 3

                                                                                Also, as a sensible dictionary would, Merriam-Webster defines both current interpretations of it: https://www.merriam-webster.com/dictionary/open-source

                                                                            2. 4

                                                                              we already have a term meaning “open source + a particular ideology”. It’s Free Software.

                                                                              You can’t remove politics from this question; the act of pretending you can is in itself a political choice to support the status quo.

                                                                              1. 2

                                                                                You can remove “politics” from open source, and that is precisely what open source has done.

                                                                                The term open source can be operationally defined (i.e., descriptive, constructed, and demonstrable). From Wikipedia, citing the book “Understanding Open Source & Free Software Licensing.” (Though feel free to use Merriam Webster or the OED as a substitute): “source code is released under a license in which the copyright holder grants users the rights to study, change, and distribute the software to anyone and for any purpose.”

                                                                                The license terms are selected that most parsimoniously accomplish the stated definition. (i.e., make it possible for the stated definition to become externally correspondent and existentially possible). The fewest number of rules (formula, statements, decisions) possible to accomplish the work–producing a limited number of legal operations (rights, grants, privileges) that can be fully accounted for.

                                                                                It is the deflationary nature of the process that removes “politics.” Making the license commensurable and testable while removing suggestion, loading, framing, or overloading. BSD/MIT are small and shrinking, whereas GPL 2/3 are large and growing. That’s the difference.

                                                                                1. 2

                                                                                  “source code is released under a license in which the copyright holder grants users the rights to study, change, and distribute the software to anyone and for any purpose.”

                                                                                  You can still get patent sued for that due to laws paid for by lobbyists. The effects of politicians on what we can and can’t do with open-source mean it’s inherently political. The people who say they want its benefits with no interest in politics or whose licenses don’t address it are still involved in a political game: they’re just not players in it.

                                                                                  1. 1

                                                                                    I’m not sure why do you think I’m trying to “remove politics”. Of course I do have some political view on this, however vague it might be. This is totally beside the point. The point is that I don’t want to proclaim/discuss my political views every time I want to say that the code is available. It’s a completely valid desire.

                                                                                  2. 1

                                                                                    Why BSD license over public domain? The latter makes the source code more “available”, does it not?

                                                                                    (If you wonder how I feel about the GPL, check my repos.)

                                                                                    1. 11

                                                                                      The latter makes the source code more “available”, does it not?

                                                                                      No. In jurisdictions that don’t recognise public domain (e.g. France) and in which authors cannot give up their copyright, giving it to the public domain is meaningless and it’s as if the code has no free license at all. It’s the same as “all rights reserved”.

                                                                                      1. 2

                                                                                        That’s very interesting. Would folks in such jurisdictions be interested in working together with others to reform copyright law? Perhaps among .. other things?

                                                                                        1. 2

                                                                                          Why? It’s a different branch of copyright law and the idea of authorship being something you cannot give up is fundamental to those. You can only perpetually license.

                                                                                          CC0 is a great license to use in those cases, btw.

                                                                                          1. 2

                                                                                            Why?

                                                                                            One reason being that some people think copyright, or perhaps even more generally, intellectual property, is unethical. Another reason could be a desire for a single simple concept of “public domain,” perhaps similar to what we have in the US.

                                                                                      2. 1

                                                                                        I like the idea of retaining an exclusive right to the project’s name, BSD is explicit about it.

                                                                                    2. 10

                                                                                      Companies are profiting massively from both. The License Zero author figured out the reason is the FOSS authors focused on distribution methods instead of results. That’s why Prosperity straight up says commercial use like many non-free licenses mention. The other one says any change has to be submitted back.

                                                                                      The license needs to explicitly mention them making money or sharing all changes to achieve what you’re describing. That plus some patent stuff. The “free” licenses trying to block commercial exploitation are neither believably free nor stopping commercial exploitation after companies like IBM (massive capitalist) bet the farm on them. I mean, the results should prove they dont work for such goals but people keep pushing old ways to achieve them.

                                                                                      Nope. Just reinforcing existing systems of exploitation by likes of IBM. We need new licenses that send more money and/or code improvements back.

                                                                                      1. 3

                                                                                        It should not be the job of a license enforced by copyright to extract rents. That’s the playbook we are fleeing.

                                                                                        1. 2

                                                                                          ““open source” is not about you; it’s a movement to hijack the free software movement and turn it into something a company can profit from”

                                                                                          The commenter wrote as if they expected whatever license or philosophy was in use to prevent companies from using the software for profit or with exploitation central focus. Several companies are making billions leveraging FOSS software. One even lobbies against software freedom using patent law since suits won’t affect it. So, if the goal is stopping that and spreading software freedom, then the so-called “free” licenses aren’t working. Quite the opposite effect moving billions into the hands of the worst, lobbying companies imaginable.

                                                                                      2. 2

                                                                                        I just don’t see “open-source” being an hijack of “free software” for corporate purposes. Why would corporate care, they can exploit the free labor of free software just as much, the politics are not visible in the final software product. If anything, it seems like the social goals of free software have been diluted by other programmers who like the technical side of it, but neither care or agree about the politics.

                                                                                        1. 3

                                                                                          Why would corporate care, they can exploit the free labor of free software just as muc

                                                                                          Depends on the market. If it’s software they sell directly, the copyleft requirement means they have to give up their changes. Those changes might be generating the customers. They might also be causing lock-in. Better for them to keep their changes secret.

                                                                                          Your point remains if it’s anything that lets them dodge the part about returning changes, esp SaaS.

                                                                                          1. 3

                                                                                            I just don’t see “open-source” being an hijack of “free software” for corporate purposes.

                                                                                            It’s not really a matter of opinion. That hijacking is exactly what happened in 1998. The fact that today you forgot that this is what happened means that it worked: you stopped thinking about free software, as the OSI intended to happen in 1998.

                                                                                            OSI was created to say “open source, open source, open source” until everyone thought it was a natural term, with the goal of attracting corporate interests. They even called it an advertising campaign for free software. Their words, not mine.

                                                                                        1. 20

                                                                                          My sense now is that Alan Kay’s insight, that we can use the lessons of biology (objects are like cells that pass messages to each other), was on target but it was just applied incompletely. To fully embrace his model you need asynchrony. You can get that by seeing the processes of Erlang as objects or by doing what we now call micro-services. That’s where OO ideas best apply. The insides can be functional.

                                                                                          1. 17

                                                                                            “If you want to deeply understand OOP, you need to spend significant time with SmallTalk” is something I’ve heard over and over throughout my career.

                                                                                            1. 5

                                                                                              It’s also a relatively simple language with educational variants like Squeak to help learners.

                                                                                              1. 7

                                                                                                I have literally taken to carrying around a Squeak environment on USB to show to people. even experienced engineers tend to get lost in it for a few hours and come out the other side looking at software in a different way, given a quick schpiel about message passing.

                                                                                              2. 4

                                                                                                If you don’t have any Smalltalk handy, Erlang will do in a pinch.

                                                                                                1. 2

                                                                                                  And if you don’t have Erlang handy, you can try Amber in your browser!

                                                                                                2. 1

                                                                                                  I went through the Amber intro that /u/apg shared. I’d love to dive deeper. If anyone has any resources for exploring SmallTalk/Squeak/Etc further, I’d love to see them. Especially resources that explore what sets the OO system apart.

                                                                                                  1. 2

                                                                                                    I’m told that this is “required” reading. It’s pretty short, and good.

                                                                                                3. 16

                                                                                                  I even wrote a book on that statement. My impression is that “the insides can be functional” could even be “the insides should be functional”; many objects should end up converting incoming messages into outgoing messages. Very few objects need to be edge nodes that turn incoming messages into storage.

                                                                                                  But most OOP code that I’ve seen has been designed as procedural code where the modules are called “class”. Storage and behaviour are intertwingled, complexity is not reduced, and people say “don’t do OOP because it intertwingles behaviour and storage”. It doesn’t.

                                                                                                  1. 2

                                                                                                    This.

                                                                                                    Whether the implementation is “functional” or not, the internals of any opaque object boundary should at least be modellable as collection of [newState, worldActions] = f(old state, message) behaviours.

                                                                                                    We also need a unified and clearer method for namespacing and module separation, so that people aren’t forced to make classes (or closures-via-invocation) simply to split the universe into public and private realms.

                                                                                                    To say that the concept of objects should be abandoned simply because existing successful languages have forced users to mis-apply classes for namespacing is as silly as the idea that we should throw out lexical closures because people have been misusing them to implement objects (I’m looking at you, React team).

                                                                                                  2. 5

                                                                                                    If there’s one lesson I’ve learned from software verification, it’s that concurrency is bad and we should avoid it as much as possible.

                                                                                                    1. 8

                                                                                                      I’m not entirely sure this is correct. I’ve been using Haskell/Idris/Rust/TLA+ for a while now and I’m now of the opinion that concurrency is just being tackled at the wrong conceptual level. In that most OOP/imperative strategies mix state+action when they shouldn’t.

                                                                                                      Also can you qualify what you mean by concurrency? I’m not sure if you’re conflating concurrency with parallelism here.

                                                                                                      I’m using the definitions offered by Simon Marlow of Haskell fame, from Parallel and Concurrent Programming in Haskell:

                                                                                                      In many fields, the words parallel and concurrent are synonyms; not so in programming, where they are used to describe fundamentally different concepts.

                                                                                                      A parallel program is one that uses a multiplicity of computational hardware (e.g., several processor cores) to perform a computation more quickly. The aim is to arrive at the answer earlier, by delegating different parts of the computation to different processors that execute at the same time.

                                                                                                      By contrast, concurrency is a program-structuring technique in which there are multiple threads of control. Conceptually, the threads of control execute “at the same time”; that is, the user sees their effects interleaved. Whether they actually execute at the same time or not is an implementation detail; a concurrent program can execute on a single processor through interleaved execution or on multiple physical processors.

                                                                                                      While parallel programming is concerned only with efficiency, concurrent programming is concerned with structuring a program that needs to interact with multiple independent external agents (for example, the user, a database server, and some external clients). Concurrency allows such programs to be modular; the thread that interacts with the user is distinct from the thread that talks to the database. In the absence of concurrency, such programs have to be written with event loops and callbacks, which are typically more cumbersome and lack the modularity that threads offer.

                                                                                                      1. 5

                                                                                                        Also can you qualify what you mean by concurrency?

                                                                                                        Concurrency is the property that your system cannot be described by a single global clock, as there exist multiple independent agents such that the behavior the system depends on their order of execution. Concurrency is bad because it means you have multiple possible behaviors for any starting state, which complicates analysis.

                                                                                                        Using haskell/rust/Eiffel here helps but doesn’t eliminate the core problem, as your system may be larger than an individual program.

                                                                                                        1. 10

                                                                                                          All programs run in systems bigger than the program

                                                                                                          1. 1

                                                                                                            But that’s not an issue if the interaction between the program and the system is effectively consecutive (not concurrent), I think is the point that was being made. A multi-threaded program, even if you can guarantee is free of data races etc, may still have multiple possible behaviors, with no guarantee that all are correct within the context of the system in which operates. Analysis is more complex because of the concurrency. A non-internally-concurrent program can on the other be tested against a certain input sequence and have a deterministic output, so that we can know it is always correct for that input sequence. Reducing the overall level of concurrency in the system eases analysis.

                                                                                                            1. 2

                                                                                                              You can, and probably should, think of OS scheduling decisions as a form of input. I agree that concurrency can make the state space larger, but I don’t believe it is correct to treat concurrency/parallelism as mysterious or qualitative.

                                                                                                          2. 3

                                                                                                            Using haskell/rust/Eiffel here helps but doesn’t eliminate the core problem, as your system may be larger than an individual program.

                                                                                                            They help in reducing the scope into the i/o layer interacting with each other. I think an example would be helpful here as there isn’t anything to argue for your stated position so far.

                                                                                                            But lets ignore language for the moment and give an example from my work. We have a network filesystem that has to behave generally like a POSIX filesystem across systems. This is all c and in kernel, so mutexes and semaphores are the overall abstractions in use for good or ill.

                                                                                                            I’ve been using TLA+ both as a learning aide in validating my understanding of the existing code, and to try to find logic bugs in general for things like flock() needing to behave across systems.

                                                                                                            Generally what I find is that these primitives are insufficient for handling the interactions in i/o across system boundaries. Aka lets take a call to flock() or even fsync(), you need to ensure all client systems behave in a certain way when one (or more) systems make a call. What I find is that the behavior as programmed works in general cases, but when you setup TLA+ to mimic the mutex/semaphores in use and their calling behavior, they are riddled with logic holes.

                                                                                                            This is where I’m trying to argue that the abstraction layers in use are insufficient. If we were to presume we used rust in this case, primarily as its about the only one that could fit a kernel module use case, there are a number of in node concurrent races across kernel worker threads that can just “go away”. Thus freeing us to validate our internode concurrent behavior logic via TLA+ and then ensuring our written code conforms to that specification.

                                                                                                            As such, I do not agree that concurrent programming should be avoided whenever possible. I only argue that OOP encourages by default bad practices that one would want to use when programming in a concurrent style (mixing state+code in an abstraction that is ill suited for it). It doesn’t mean OOP is inherently bad, just a poor fit for the domain.

                                                                                                            1. 1

                                                                                                              I feel that each public/private boundary should have its own singular clock, and use this to sequence interactions within its encapsulated parts, but there can never really be a single global clock to a useful system, and most of our problems come from taking the illusion of said clock further than we should have.

                                                                                                          3. 4

                                                                                                            I would go exactly tangential and say that the best software treats concurrency as the basis of all computation. in particular, agnostic concurrency. if objects are modeled to have the right scope of visibility and influence, they should be able to handle messages in a perfectly concurrent and idempotent manner, regardless of cardinality.

                                                                                                            1. 2

                                                                                                              Take Clojure for example, and I think concurrency is not that bad, and there is no reason to avoid it. Mutability and intertwining of abstractions is what leads to problematic situations. Functional programming solves that by its nature.

                                                                                                              1. 4

                                                                                                                Even if the program is immutable, you ultimately want the program to have some effect on the outside world, and functional programming doesn’t magically fix the race conditions there. Consider having a bunch of immutable, unentwined workers all making HTTP requests the same server. Even if there are no data races, you can still exceed the rate limit due to concurrency.

                                                                                                          1. 7

                                                                                                            @friendlysock, the post in question was going to be problematic regardless of our community health at the moment it was posted. Just look at the vote counts you highlighted. Crustaceans clearly have strong feelings about that company.

                                                                                                            That being said… yes, this would be a good time to inoculate new comers, re-inoculate old-timers, and push out those that resist.

                                                                                                            …I don’t know how to reply or otherwise respond to the chronologically first comment on your post. I have many skills, but not-making-it-worse is not one of them. Help? I want to say something like “No, just no. We’re doing a thing here. Watch us and do like us, or leave.”

                                                                                                            1. 11

                                                                                                              @friendlysock, the post in question was going to be problematic regardless of our community health at the moment it was posted. Just look at the vote counts you highlighted. Crustaceans clearly have strong feelings about that company.

                                                                                                              Having strong feeling is one thing, knowing which places are good to discuss them is another. It seems to me that with each passing month more and more people think that lobste.rs is good place to discuss anything they find interesting/important.

                                                                                                              Part of the problem, is that there are no explicit content rules - it’s hard to ask others to stop posting any kind of content if there are no guidelines what is and isn’t accepted here.

                                                                                                              1. 7

                                                                                                                One part of @friendlysock’s post struck me:

                                                                                                                This site is for practicing technologists and for people trying to learn about technology and better themselves as engineers and developers.

                                                                                                                I think it would be helpful if this or something similar was added to the story submitting guidelines on the Submit Story page. It would be more explicit than the current “if no tags apply, your story is off-topic” suggestion.

                                                                                                                1. 8

                                                                                                                  Keep in mind, that is @friendlysock’s line, not an “official” Lobsters policy. I happen to agree with them, but I think that the truth is closer to @tt’s remark that this has always been a “place to discuss anything [the users] find interesting/important. Unspoken rules have but little force.

                                                                                                                  1. 3

                                                                                                                    It’s his view, not Lobsters’. I think, could be misremembering, there used to be more people agreeing with his view. The submissions were consistent with it when I came in. The votes went the other way in a later meta after they did for representative threads and comments. I’m guessing most people doing mass invite brought in people like them. Most of people that came in have the newer leanings about political posts. There were many before, though.

                                                                                                                    Now, the majority opposes friendlysock’s position in day-to-day use of the site, votes, and comments. It’s why my welcomes that use the What Lobsters Is and Isn’t write-up don’t say it’s our rules or official policy: I just encourage them to focus on What Lobsters Is for high-quality, technical submissions that will be well-received by people focused on that.

                                                                                                                  2. 7

                                                                                                                    This only makes sense if that actually is the sole purpose of the site, but I don’t believe there’s agreement on that point, despite @friendlysock continually speaking as if there is, and as if he speaks for the community as a whole.

                                                                                                                    1. 6

                                                                                                                      for people trying to learn about technology and better themselves as engineers and developers.

                                                                                                                      In particular, the implication that bettering yourself as an engineer is unrelated to understanding the ethical implication of your work is deeply disturbing to me.

                                                                                                                      1. 8

                                                                                                                        Do you believe that the posts in question actually furthered our understanding of the ethical implications of the work? To me, it read more like low effort shaming, or an attempt to stroke a sense of moral superiority.

                                                                                                                        Out of all ethical discussions on this site, what portion do you think further our understandings of ethical implications?

                                                                                                                        1. 4

                                                                                                                          That is not the implication I get at all. What I read is that “understanding the ethical implication of our work” is something we could agree to do elsewhere.

                                                                                                                          1. 2

                                                                                                                            I don’t see how what you said can be true without what I said.

                                                                                                                            If understanding ethical implication of your work is part of being a better engineer, then it’s a suitable topic for a site whose purpose is “trying to […] better themselves as engineers”.

                                                                                                                  1. 3

                                                                                                                    My head is spinning. I appreciate it’s neat to enable dynamic-like workflows on top of a blog that’s actually just static files, but I would take a makefile+rsync on my laptop over this any day.

                                                                                                                    I guess this enables webmentions which my setup doesn’t, but … wow, what a cost of entry. Is there some other advantage I’m missing?

                                                                                                                    1. 3

                                                                                                                      I guess this enables webmentions which my setup doesn’t, but … wow, what a cost of entry. Is there some other advantage I’m missing?

                                                                                                                      I feel exactly the same!

                                                                                                                      I’m very fond of the static website approach. My website has always been static. This approach is really simple and has very few moving parts. For instance:

                                                                                                                      1. My website is hosted on a raspberry-pi sitting in a associative datacenter. Some of my posts reached the top section of some link aggregators (here, hn, reddit, …); my webserver just took the hit pretty easy, the load never exceeded 0.4. When I see some websites sitting on fat ass server being ddosed in the same condition, I feel like serving static files makes your website clearly easy to maintain/scale.
                                                                                                                      2. Yesterday, my HDD failed. Shit happens [1]. I was just a make publish and a DNS zone modification away of being online again. I could never done that with a dynamic website.

                                                                                                                      However, I’m also very fond of the ideas pushed by the indie web community. The amount of tooling they built to make POSSE [2] easier is pretty impressive. The whole micropub/microsub workflow and associated UX is amazing. I can’t make this fit with my current workflow; it drives me crazy.

                                                                                                                      I built a whole micropub/sub prototype based on @myfreeweb’s sweetroll using a hugo backend and generating webpages on the fly. It does not work reliably, it is crazily complex. It feels like I’m re-inventing a whole cache system. I feel like the two approach simply does not fit together. (I’ll probably write an article on this experiment in a near future).

                                                                                                                      So, in the meantime, I try to advertise the indieweb values by posting stuff they write to a broader community (here for instance :)) and pushing their standards where it is possible without adding too much complexity. I do that in the secret hope somebody smarter than I am will manage to make the two approach fit together :D

                                                                                                                      [1] Have to admit I have been lucky on this one. My backups are fired at 12:00, the hard-drive failed at 2PM. I almost did not lose anything at all.

                                                                                                                      [2] Publish (on your) Own Site, Syndicate Elsewhere”.

                                                                                                                    1. 5

                                                                                                                      Somebody on mastodon pointed out a couple problems with this article that I missed on first read-through:

                                                                                                                      • it confuses the system’s teleology with the ruling class’s teleology. VCs and tech management probably don’t union-bust or embrace Hank Scorpio style false class equivalence in order to drive wages down, because they probably don’t actually have a mental model of how industries work – they are probably doing these things because it’s part of the culture, and no mastermind exists. The article says a lot of “CEOs do X because Y” when they should be saying “When CEOs do X, the result is Y”, rather than implying that CEOs know what they’re doing and are doing it intentionally.
                                                                                                                      • some of the claims about hackathons & coding bootcamps are more specific to the united states than the author seems to think. The guy who pointed this out claims that in New Zealand hackathons are largely non-profit community projects & coding bootcamps aren’t focused on getting high-paying tech industry jobs; not sure if his view is representative of NZ in general, but he thought the idea of hackathons being a tool of capitalism totally alien.
                                                                                                                      • the focus on labour eliminates the intersection of labor and various essentially-political movements in the tech sphere (free culture, copyfight, open source, net neutrality, slow tech), even though the deradicalization of these movements by the industry (freewashing, the movement from free software to ‘open source’) can be interestingly compared to other kinds of ‘perks’. Because deradicalization defangs movements that are agitating for genuine change, it’s a much bigger deal – freewashing harms the whole community, while a ping pong table in the lounge just helps scam a handful of ping pong fans into becoming employees.
                                                                                                                      1. 2

                                                                                                                        The article says a lot of “CEOs do X because Y” when they should be saying “When CEOs do X, the result is Y”, rather than implying that CEOs know what they’re doing and are doing it intentionally.

                                                                                                                        This is a great point; the emergent outcomes of “this is how it’s done” are just as harmful if not more harmful than a shadowy cabal of conspirators. In particular, if you ascribe it to intention it’s a much weaker argument, because counter-examples of folks acting without that malicious intent are easy to find.

                                                                                                                        1. 4

                                                                                                                          On top of that, the appropriate strategies for dealing with systemic stuff are very different from the appropriate strategies for dealing with people who have particular (undesirable) intentions or plans. In the latter case you can convince those people, or fight them directly, or take away their power; in the former case anybody in that position is liable to act the same way, so you need to fundamentally restructure incentives.

                                                                                                                      1. 2

                                                                                                                        I think of Haskell as one of the more academic programming languages, so seeing that Reddit was the most common place to discuss it seems very strange to me as Reddit strikes me as quite sophomoric.

                                                                                                                        1. 12

                                                                                                                          Reddits communities are sometimes very sophisticated. Typically, it depends on the mods. Also i have seen subreddits turn bad when they were included in the front page.

                                                                                                                        1. 9

                                                                                                                          Completeness can be sacrificed in favor of any other quality. In fact, completeness must be sacrificed whenever implementation simplicity is jeopardized. Consistency can be sacrificed to achieve completeness if simplicity is retained; especially worthless is consistency of interface.

                                                                                                                          In a way the so called “New Jersey style” was a rush for a minimum viable product able to minimize the time-to-market and to gain the first mover advantage.

                                                                                                                          These are grim tidings indeed.

                                                                                                                          Everyone who works in software sees broken, dysfunctional systems that just keep getting worse with time. More and more money goes into working around their deficiencies, and real fixes are rare. Everyone who works in software thinks “surely there has to be a better way” but according to Gabriel, the forces of survival-of-the-fittest say “no, there can’t be a better way. I won’t allow it.”

                                                                                                                          We see good software in side-projects, in fun weekend hacks, and we go to work thinking “if I were in charge here, this would be like that”, but it can’t be. In a sufficiently competitive environment, “messy and now” beats “clean, but tomorrow” every time.

                                                                                                                          1. 4

                                                                                                                            Reading your comment I was filled with sorrow, because it feels so very right. But the more I thought on it, I realize that often “clean, but tomorrow” morphs into “clean, but next year,” if you’re not careful. And being given carte blanche to deliver whenever doesn’t work for businesses, and unless you’re a philosophic communist, we’re all in the business of something. The important part is striking the right balance between doing it well enough and delivering it on a decent timeline. That’s what you get from a high performing team, and that’s why processes like agile arose. And that’s life too: constraint balancing. Often those constraints are interpreted as bad, but that value judgement comes from us, not the constraint.

                                                                                                                            Put another way, there is no ivory tower where everything is perfect and all solutions are fully explored.

                                                                                                                            1. 2

                                                                                                                              Put another way, there is no ivory tower where everything is perfect and all solutions are fully explored

                                                                                                                              …and money is made.

                                                                                                                            2. 2

                                                                                                                              The environment doesn’t even need to be competitive. It just needs to involve money and people wanting what they tend to want: things done cheap.

                                                                                                                            1. 3

                                                                                                                              I wonder if “Worse is fitter” would have been a clearer way for Gabriel to express the sentiment. (“fitter” here being in the “survival of the fittest” sense) “Better” is too overloaded and value-driven, tho of course it’s much more catchy that way.

                                                                                                                              Perhaps the popularity of “worse is better” is in itself an instance of the “worse is fitter” phenomenon.

                                                                                                                              1. 1

                                                                                                                                (on an unrelated note, I would have upvoted this if it weren’t hosted on medium.com)

                                                                                                                                1. 1

                                                                                                                                  I think that’s a more accurate way of saying it, but there are other caveats.

                                                                                                                                  If we wanted to encode all the important parts of that essay into a single phrase, it would be something like “stupid and lazy is sometimes profitable in the short term”.

                                                                                                                                  1. 2

                                                                                                                                    Luckily this post is on medium!

                                                                                                                                    1. 15

                                                                                                                                      At first I was really annoyed by that too! Then I realized …

                                                                                                                                      the Medium is the message.

                                                                                                                                      1. 3

                                                                                                                                        Ugh. If it weren’t, I might actually read it. As it is, I’ll refrain from attempting to derive it from first principles here without peeking. Too easy. The headline says enough.

                                                                                                                                        1. 3

                                                                                                                                          Reader mode works nicely, tho of course without images, because Medium doesn’t use the img tag correctly.

                                                                                                                                          1. 1

                                                                                                                                            The image tags look fine to me in the inspector? Also Reader mode seems to work with them, thankfully. Is this something that changed recently?

                                                                                                                                            1. 1

                                                                                                                                              I’m guessing viewing the images requires having 3rd-party scripts unblocked, which in my book still qualifies as “doesn’t use the img tag correctly”.

                                                                                                                                      1. 8

                                                                                                                                        My two cents: find a way to make remote work maintainable for you.

                                                                                                                                        1. 5

                                                                                                                                          Agreed.

                                                                                                                                          I’ve looked at coworking spaces, but finaicially it’s not a possibility right now. The company also will not reimburse for it.

                                                                                                                                          They might change their tune if they knew that not having a coworking space is making you consider leaving the company. If you can make it clear that this is a requirement for your job and the alternative is hiring someone else, then in most cases they will pay for it.

                                                                                                                                          1. 1

                                                                                                                                            I’ve never really considered this way of thinking.

                                                                                                                                            I would assume most companies would just view you as dead weight or an extra cost (why give this remote worker money to co-work when I am saving money by not having them in the office)

                                                                                                                                            1. 1

                                                                                                                                              It depends on how replaceable you are of course, but the cost of training a replacement for many folks who write and operate software is very high, so people are incentivized to avoid that kind of disruption.

                                                                                                                                              1. 1

                                                                                                                                                I agree completely! I suppose I’m just jaded from previous jobs where most people had left until it was only contractors left (no full time employees left)

                                                                                                                                          2. 3

                                                                                                                                            is that because you think the startup opportunity is too good to walk away from? or remote work is too good to walk away from? or a combo?

                                                                                                                                            1. 10

                                                                                                                                              I’m not /u/zpojqwfejwfhiunz, but I agree with him on this.

                                                                                                                                              Being remote gives you a lot of flexibilty, and there are quite a few ways to work outside of the house that don’t have to involve being in a co-working space, such as coffee shops or parks. This may not work as well on meeting days, but it is worth investigating. Also, if you’ve not been taking advantage of working remotely, maybe start trying to get creative about flexing those privileges.

                                                                                                                                              Does your current company pay for you to visit them once in a while? Are you living with anyone? Can you have pets in your current housing? Do you have regular social contact with people that will help you grow? I know for me, working remote allowed me to move closer to family and friends I hadn’t seen in a long time, which did far more to attack the problem of lonliness than working in an office did. I moved 1300 miles to pull that off. Perhaps that sort of move might make sense for you?

                                                                                                                                              I would attack the lonliness angle from outside of work before I would switch to working at a local company, and I’d do a lot of research on the local company before I switched. Maybe make a friend or acquaintance there via a shared social gathering, or the like, and get a sense of what the company politics are like, or if people there like the company culture. It sounds like you have great co-workers, that’s not something to be set aside lightly.

                                                                                                                                              In other words, take advantage of working remotely to be able to surround yourself with people that will build you up. If you can’t figure out a way to make that work (and you have been working remotely for 4 years, so that seems quite possible), then I’d consider working in an office, but not before.

                                                                                                                                              1. 9

                                                                                                                                                such as coffee shops or parks

                                                                                                                                                …and libraries!

                                                                                                                                                Libraries are so undervalued it’s unreal. I’ve been working remotely for the past 4/5 years, and while I do sometimes work from cafés, there is an implicit social pressure to keep buying things to justify taking up a table. No such problem with a library. If you’re in a big city, these can be incredibly beautiful buildings too.

                                                                                                                                                1. 3

                                                                                                                                                  Thats such an amazing idea. If I go remote this would be my main place to work at. Its such a nice building but I rarely have a reason to go there.

                                                                                                                                                  1. 3

                                                                                                                                                    Thats such an amazing idea. If I go remote this would be my main place to work at. Its such a nice building but I rarely have a reason to go there.

                                                                                                                                                    It’s cool, I’ve tried it - only downside is private rooms for calls are not always around.

                                                                                                                                                2. 4

                                                                                                                                                  thanks for the well thought out reply!

                                                                                                                                                  • certainly going to attempt working outside a bit more
                                                                                                                                                  • social contact with others seems to be a common thread, not currently doing much of that
                                                                                                                                                  • approaching the local company from the inside makes a lot of sense
                                                                                                                                                  1. 3

                                                                                                                                                    Yeah, when you’re working remotely, being able to fill your social needs outside of work is key.

                                                                                                                                                    In some ways, you could view it as an advantage of working remote. After all, you don’t have a commute, that frees up some of that time to be spent elsewhere. Be intentional about spending it elsewhere.

                                                                                                                                                    1. 4

                                                                                                                                                      Along these lines, I personally find that limiting media consumption is critical. It’s better to force yourself to be bored than to always have the TV on or be staring at a screen. That boredom will force you to find other hobbies. Ideally, you’d find at least one athletic hobby, and at least one social hobby.

                                                                                                                                            1. 3

                                                                                                                                              I wish the article were a bit more substantive.

                                                                                                                                              They touch on type inference. Does anyone have some refs for how to do this in Lisp?

                                                                                                                                              1. 6

                                                                                                                                                They touch on type inference. Does anyone have some refs for how to do this in Lisp?

                                                                                                                                                Henry Baker has a paper about it: The Nimble Type Inferencer for Common Lisp-84

                                                                                                                                                http://home.pipeline.com/~hbaker1/TInference.html

                                                                                                                                                1. 4

                                                                                                                                                  You don’t do this, the compiler does it for you. Inferring it from the code, with or without the aid of type declarations by programmer.

                                                                                                                                                  The article has the example of declaring the types, which allows compiler to infer tight, specialized code.

                                                                                                                                                  1. 2

                                                                                                                                                    Sure, agreed. But in my case, I’m implementing the compiler. So I was hoping for some refs on how to do type inference.

                                                                                                                                                    1. 12

                                                                                                                                                      SBCL implements it as type propagation using dataflow analysis. Types in some places are known from explicit declarations, constant literals, known functions, etc., and this information is propagated in a pass named “constraint propagation”, to infer the types of other expressions when possible.

                                                                                                                                                      I’m not sure whether there’s proper documentation anywhere, but this post on some of the type propagator’s weaknesses starts with a summary of how it works [1].

                                                                                                                                                      “Gradual typing” has become a trend outside the Lisp world lately, and I believe those systems do something vaguely similar to propagate types. That might be another place to find implementation hints.

                                                                                                                                                      [1] Note when reading this post that “Python” is the name of SBCL’s compiler; the name predates Guido van Rossum’s language. The reason the compiler has a separate name in the first place is that SBCL’s predecessor, CMUCL, had an interpreter, a bytecode compiler, and a native-code compiler, and Python was the name of the native-code compiler.

                                                                                                                                                      1. 2

                                                                                                                                                        SBCL implements it as type propagation using dataflow analysis. Types in some places are known from explicit declarations, constant literals, known functions, etc., and this information is propagated in a pass named “constraint propagation”, to infer the types of other expressions when possible.

                                                                                                                                                        Ah! Interesting! This is what I was planning to do with my toy lisp :) It might be worth for scholary searches, I heard it first when using Erlang under the name of Succession Typing. I could be completely remembering, but I think Dialyzer uses this method of program typing.

                                                                                                                                                        1. 2

                                                                                                                                                          I don’t think this is quite the same thing as Dialyzer’s Success Typing, though there might be some overlap. Dialyzer’s goals are very different in that it’s only concerned with correctness and not performance. But it might use some similar methods.

                                                                                                                                                      2. 2

                                                                                                                                                        This may help, it’s an overview of FB’s Flow system for JS https://www.youtube.com/watch?v=VEaDsKyDxkY