Which company? Octobus? As per their website, there are only 2 people, and Pierre-Yves David (“marmoute”) is a well know core Mercurial contributor. The company itself is about providing commercial support for Mercurial, along with other stuff like Python contracting.

I use Mercurial at work. My company uses Git, but I use Mercurial and clone, push, and pull transparently thanks to hg-git. I’ve noticed I am generally more aware than my Git-using colleagues of recent changes to the repo, because I’ve got a pre-pull hook set up to run hg incoming (with a tweak to avoid double network talk).

but on the other hand, it’s got to be grating to deal with the same entitled, uninformed or complaining comments all the time.

Over the years, I have come to believe this is a vital part of building a community. Using draconian tactics to stomp out annoying comments is using power unwisely and worse yet – cripples your community in multiple ways.

The first thing to remember is that when a comment (entitled, uninformed or otherwise) comes up repeatedly – that is a failure of the community to provide a resource to answer/counter/assist with that comment. That resource can be a meme, a link, an image, a FAQ, a full on detailed spec document, whatever. This type of thing is part of how a community gets a personality. I think a lot of the reason there are a bunch of dead discourse servers for projects is too stringent policing. You should have a place for people to goof off and you have to let the community self police and become a real community. Not entirely, obviously, but on relevant topics.

This constant repetition of questions/comments is healthy, normal, it is the entrance of new people to the community. More importantly, if gives people who are just slightly deeper in the community someone to help, someone to police, someone to create resources for, even to a degree someone to mock (reminding them they aren’t THAT green anymore) – a way to be useful! This is a way to encourage growth, each “generation” of people helps the one that comes after them – and it is VITAL for building up a healthy community. In a healthy community the elders will only wade in occasionally and sporadically to set the tone and will focus on the more high minded, reusable solutions that move the project forward. Leave the minor stuff be done by the minor players, let them shine!

Beyond being vital to build the community – it is a signal of where newcomers are hurting. Now if documentation fixes the problem, or a meme… terrific! But if it doesn’t, and if it persists … that is a pain point to look at – that is a metric – that is worth knowing.

I’ll add the perspective of someone who loved Elm and will never touch it again. We’re rewriting in PureScript right now :) I’m happy I learned Elm, it was a nice way of doing things while it lasted.

In Elm you may eventually hit a case where you can’t easily wrap your functionality in ports, the alternative to native modules. We did, many times. The response on the forum and other places is often to shut down your message, to give you a partial version of that functionality that isn’t quite what you need, to tell you to wait until that functionality is ready in Elm (a schedule that might be years!), or until recently to point you at native modules. This isn’t very nice. It’s actually very curious how nice the Elm community is unless you’re talking about this feature, in which case it feels pretty hostile. But that’s how open source rolls.

Look at the response to message linked in the story: “We recently used a custom element to replace a native modules dealing with inputs in production at NoRedInk. I can’t link to it because it’s in a proprietary code base but I’ll be writing an speaking about it over the next couple months.”

This is great! But I can’t wait months in the hope that someone will talk about a solution to a problem I have today. Never mind releasing one.

Many people did not see native modules as a shortcut or a secret internal API. They were an escape valve. You would hit something that was impossible without large efforts that would make you give up on Elm as not being viable. Then you would overcome the issues using native modules which many people in the community made clear was the only alternative. Now, after you invest effort you’re told that there’s actually no way to work around any of these issues without “doing them the right way” which turns out to be so complicated that companies keep them proprietary. :(

I feel like many people are negative about this change because it was part of how Elm was sold to people. “We’re not there yet, but here, if we’re falling short in any way you can rely on this thing. So keep using Elm.”

That being said, it feels like people are treating this like an apocalypse, probably because they got emotionally invested in something they like and they feel like it’s being changed in a way that excludes them.

You’re right though. Maybe in the long term this will help the language. Maybe it will not. Some people will enjoy the change because it does lead to a cleaner ecosystem and it will push people to develop libraries to round out missing functionality. In the short term, I have to get things done. The two perspectives often aren’t compatible.

I’m personally more worried about what will happen with the next major change where Elm decides to jettison part of its community. I don’t want to be around for that.

I would prefer that the discussions weren’t removed or locked, but on the other hand, it’s got to be grating to deal with the same entitled, uninformed or complaining comments all the time. I’ve read most of these discussions, and other than people venting, nothing is ever achieved in them. My reflexive reaction is to be uncomfortable (like a lot of other people) but then, there is also a certain clarity when people just say that they will not engage in a discussion.

I’ll go one further and say I’m quite glad those discussions get locked. Once the core team has made a decision, there’s no point in having angry developers fill the communication channels the community uses with unproductive venting. I like the decisions the core team is making, and if those threads didn’t get locked, I’d feel semi-obligated to respond and say that I’m in favor of the decision, or I’d feel guilty not supporting the core devs because I have other obligations. I’m glad I don’t have to wade through that stuff. FWIW, it seems like the community is really good at saying “We’re not going to re-hash this decision a million times, but if you create a thread about a specific problem you’re trying to solve, we’ll help you find an approach that works” and they follow through on that.

I don’t have a lot of sympathy for folks who are unhappy with the removal of the ability to compile packages that include direct JS bindings to the Elm runtime. For as long as I’ve been using Elm the messaging around that has consistently been that it’s not supported, it’s just an accidental side effect of how things are built, and you shouldn’t do it or you’re going to have a bad time. Now it’s broken and they’re having a bad time. This should not be a surprise. I also think it’s good decision to actively prohibit it. If people started using that approach widely, it would cause a lot of headaches for both the community and hamstring the core team’s ability to evolve the language.

I think what bothers me the most about the core team’s approach to features is not that they keep removing them, but that for some they do not provide a valid alternative.

They’ll take away the current implementation of native modules, but coming up with a replacement is too hard, so even though the core libraries can use native code, us peasants will have to do without.

They won’t add a mechanism for higher rank polymorphism because coming up with a good way to do it is hard, so even though the base library has a few magic typeclasses for its convenience, us peasants will have to make do with mountains of almost duplicated code and maybe some code generation tool.

So where does that leave Elm right now? Should it be considered a production-ready tool just by virtue of not having very frequent releases? Or should it be regarded as an incomplete toy language, because of all the breaking changes between releases, all the things that haven’t been figured out yet, and how the response to requests for ways to do things that are necessary in real code is either “you don’t need that”, which I can live with most of the time, or “deal with it for the moment”, which is unacceptable.

I think Elm should make it more clear that it’s ostensibly an unfinished project.

I was hoping to read other points of view on that matter, thanks for taking the time writing down yours!

They actually did lock the post. As in here’s how we prove you right.

That reads like a copy paste that’s not actually in response to the article?

One interesting thing I immediately noticed about that is that it isn’t a single moderate (despite them having them) – it is a collective, the “elm_mods”. This feels like a shield allow the mods to be harsher than they might be as an individuals because no individual is ever responsible for the posts from “elm_mods”.

This came from realizing that useful products do not really need much marketing.

But, they do need some. You have to be aware a product exists, outside of shifting power to an intermediary between you and the product – what do you consider acceptable?

Perhaps you are just refusing to see how you have been influenced by adverts.

It’s interesting that you say that. I try to consciously avoid paying attention to ads or seeing them at all. I don’t watch broadcast television, for example.

But ads undeniably get in there anyway, and think about it: think of a fast food place. Think of a brand of toothpaste. Ads aren’t just about yelling at you to go buy a particular thing, they’re also about brand awareness. There are the really obvious ads like the Coke ads where they have people drinking coke and looking like they’re happy, but they’re quite transparent. What I really hate is the pervasive advertising of brands just so that you, when you think of a product, think of their brand. And that’s hard to stop, even if you’re consciously aware of it.

It has also been about announcing the availability of products and making innovations known outside eg. journals. Stuff people may need.

I’m not defending modern advertising, or all old advertising, but the ads of old were a lot more understandable in how and what kinds of reactions they were trying to evoke. You could reason your way around an ad for cigarettes, but you can’t reason your way around invisible yet targeted ad networks.

So this communist-Cuba approach to advertising is understandable, but calling it just another technique is a bit harsh and underestimates the audience.

I’d even go so far as to say the inefficiency of classifieds and such are a self-regulatory system, which should not be removed lest more and more people do believe they need a new microwave oven every year.

If anyone is interested in a more detailed history of the topic, I can recommend Curtis’ The Century of the Self. Even though it’s quite informative, it’s easy to follow along.

An even better formulation would be “Here is the source code for an app where I didn’t use a framework. It has users, and here are my observations on building and deploying it”.

In other words, “skin in the game” (see Taleb). I basically ignore everyone’s “advice” and instead look at what they do, not what they say. I didn’t see this author relate his or her own experience.

The problem with “when you should” is that the author is not in the same situation as his audience. There are so many different programming situations you can be in, with different constraints, and path dependence. Just tell people what you did and they can decide whether it applies to them. I think I basically follow that with http://www.oilshell.org/ – I am telling people what I did and not attempting to give advice.

(BTW I am sympathetic to no framework – I use my own little XHR wrapper and raw JS, and my own minimal wrapper over WSGI and Python. But yes it takes forever to get things done!)

I definitely agree with this change. It’d get more people thinking architecturally, something that’s sorely needed.

I’ve yet to see a web framework I truly enjoy using. Most of them don’t even try to tame the incidental complexity of the web, preferring to heap on even more. I think this is because the type of people that make web frameworks often love the web to the point where they’re blind to the incidental complexity.

These frameworks seem to take special delight in taking over every aspect of your application, because ‘convention.’ Apparently, one of the greatest evils of software development is that there is no standard directory for models unless we institute The Right Way. Meanwhile, massive coupling makes testing difficult, causing years of “Fast tests using this one weird trick” presentations continue to be given.

The best libraries are the ones you can lock away somewhere and forget about.

I have slowly migrated from vim to kakoune. The design document spells out a lot of what I like about it, which I will repeat a bit here.

In addition to what is great about kakoune is what I have grown to dislike about vim. Neovim added a terminal to it, which I thought was a great fit for it and I had hoped vim would stick to being “just an editor” – but it didn’t – it chased neovim despite mocking such things as a terminal in an editor right in its help file. /rant

Anyway, kakoune isn’t perfect, and it isn’t even 1.0. But the author of it has very firm goals for what he wants it to do – and as importantly what he doesn’t want it to do.

So things I love (again, a lot of this is also in the design document):

• Multiple cursors: a lot of editors have this feature, but it is the only operating mode of kakoune. When you have a single char under the cursor, that is a single 1 char selection.
• Limitations: it doesn’t manage windows, tmux or i3 or (other thing) does; it doesn’t try to be multithreaded; it isn’t a file manager; it isn’t a terminal; it doesn’t have its own scripting language; it doesn’t support binary plugins; it avoids being “clever” based on context confusing the user. It makes no attempt to be all things to all people, it is a fantastic editor… this ties into composability.
• Composability: it makes no effort to implement a sort or have its own scripting language, it outsources this stuff to the existing sort command and gives tools for interacting with system tools. This is a bit of a mixed bag at this point – you get a bit of escape hell in shell scripts.
• Client/Server: a core part of the architecture.
• Powerful primitives: built right in is stuff for selection rotation, case manipulation, alignment, and tons more.
• Info boxes: last but not least, the info box feature is fantastic, when you are using a command it lets you know the parameters, when you hit like “g” for goto, it shows all the stuff that can follow “g” (like “f” for file). This is easy to add to your own custom commands as well and makes learning the editor interactively amazing.

It isn’t all great (yet) from my perspective:

• Documentation: it exists, there is a :doc feature. But a lot of it is thin and a bit hard to find. I suspect some of this is because people lean on the info boxes feature a lot and it doesn’t get as much use as it would in Emacs or Vim. But I consider it a great place for improvement. Would love a :doc changelog for example.
• Breaking changes: it isn’t 1.0 yet, and the author is still trying to improve some core features, which means breaking changes will happen, and they will break your workflow for a bit. Thus far most of these breaking changes only take minutes to fix.
• Binaries: it isn’t 1.0 yet, it moves fast, so the best way to stay up to date is absolutely to build it yourself. The good news is this only takes a few minutes at most, and its library/etc requirements are relatively low.

Along these lines, I also found micro.

The nice thing about Acme is that it’s command set is so minimal and quasi-irreductible (except for the window management stuff, that could be handled by another program).

And “modernity” is a very relative term, so all I’ll say is that it encourages you to use unix as your ide and gives you a simple interface to do so with. So as long as your unix-like system is secure and up to date, you’ll always be using top of the line tools.

What mouse are you using with it? A lot of the Acme loyalists get good old three button mice.

Sure. It was the standard #ac130d that’s used around the site, but I’ve dimmed it to #740804.

Alternatively, change the bar into a conga line of lobster emojis.

You got most of what I was going to post!

Mike Acton’s talk about Data Oriented Design has so much great stuff on how to approach development generally (despite being a CppCon talk). It is probably the single talk that had the biggest impact on me as a developer, wish he gave it a decade earlier.

maybe permissions? at least they used to be

Which also sucks… I hate carrying two phones… for awhile I had to carry three.

And I assume @tedu will be in charge of the TLS certificates?

That sounds like a great plan, thanks for putting that together. I’ll feel better knowing the site will be managed by a group instead of falling all on one person.

This sounds great. I’m thrilled to see people working together on this. :)

I got back from talking to the people planning out the transition (aleph, push, socky, goodger, alyn, 355, irenes) on Mumble and IRC - they’ve all been wonderful people putting in their best to ensure the community will experience a smooth transition and avoid any turmoil.

Awesome, glad to have regulars and good people taking things over.

I would strongly recommend, and as a lobste.rs regular personally request that as a group you take a bit of time to define some basic agreement about decision making and ownership, so that it is clear between you all, and also to the community.

This is not a problem when there’s one guy in charge - it’s simple and clear and whether you agree with them or not you have consistency and stability (thanks @jcs !)

When there’s more than one, you need extremely strong value alignment and high levels of trust. If you guys have not known each other for 5+ years and can meet in the same bar to share a beer, you need to talk about and get down some basics. Who makes decisions, how, when; who is in control of the domain / hosting / features / community management.

Personally, I like the ‘benevolent dictator’ situation. It reduces ambiguity and facilitates short sharp clear decisions. Greater than 2 people needs work to define that recognises that you will eventually have a conflict, that some of you will come and go, and that there is no way you can all have perfect understanding of what each other wants for this community and what your values are.

Not doing this is a valid choice too; equal to commitment to cede to whoever has ‘root’ and control of the hosting and then domains if a conflict happens, and requiring proactively thinking about forking / commuity splits.

Thank you all. I work a lot, don’t know Rails, and don’t really have anything constructive to contribute, but this is far and away the best signal to noise community I’m involved with and I really appreciate it.

If throwing money at the problem will help the new maintainers along please consider setting something up and I’ll chip in.

Does this mean we can finally get an @angersock plushie?

You guys were my first thought when I saw this post lol. Thanks for your continued commitment to the community ~

Thanks @angersock, @pushcx, @355e3b, @alynpost!

I’d hate to see lobsters die!

I love how fast this plan was put together and I feel it will be in good hands. I was scared seeing this post and am excited to see the community I love will keep going and be in good hands!

You’re saying that ST was great 4-5 years ago, but apart from the langserver, which one of your points didn’t apply back then as much as it does now? You say that “today there are better editors”, but surely vim is much older than 4-5 years and basically didn’t change.

I think the really ground-breaking feature that ST introduced was multi-cursor editing. Now most editors have some version of that. Once you get used to it, it’s very convenient, and the cognitive overhead is low.

As for the mini-map, I suppose it’s a matter of taste, but I found it very helpful for scanning quickly through big files looking for structure. Visual pattern recognition is something human brains are ‘effortlessly’ good at, so why not put it to use? Of course, I was using bright syntax hilighting, which makes code patterns much more visible in miniature. Less benefit for the hilight-averse.

I’ve been using ST3 beta for a few years as my primary editor. I tried using Atom and (more recently) VS Code, but didn’t like them as much: the performance gap was quite noticeable at start-up and for oversized data files. The plug-in ecosystems might make the difference for some folks, but all I really used was git-gutter and some pretty standard linters. For spare-time fun projects I still enjoy Light Table, but it’s more of a novelty. I’m gradually moving away from the Mac and want a light-weight open-source editor that will run on any OS.

So now, as part of my effort to simplify and get better at unix tools, I’m using vis. I’m enjoying the climb up the learning curve, but I think that if I stick with it long enough, I’ll probably end up writing a mouse-mode plugin. And maybe git-gutter. Interactive structural regexps and multi-cursor editing seem like a winning combination, though.

I’ve started using vim for work, and although I’ve become quite fast, I find myself missing ST’s multiple cursors.

I might try switching to a hackable editor like Yi. I’ve really enjoyed using xmonad recently for that reason.

In general I agree, but Twitter for some reason likes to load wrong tweets when I follow a shared link. I know they are wrong because username in URL is clearly not the same as tweet’s author.

Luckily I don’t have to do that often and this behaviour comes and goes. Still, while listed problems may be overstated I think they still exist.

Yeah — pretty much all the SPA tooling that exists includes a URL routing library/component/thingy. I literally never saw a public web app where URL stuff is broken.

There’s a bit of a difference between Phrenology and the sorts of scientific studies carried out on this topic today. Further, everybody claiming there isn’t a difference is either a) ignorant of the state of current research or b) pushing a false equivalence to further their own agendas for what they believe is correct.

Scientists have voiced that the science is accurate, others have put up much more thoroughly sourced articles. The science isn’t in question, really, by people that actually know the science.

This leaves us with the policy conclusions. The conclusions of:

• “Hey, maybe we should see how we can better serve women”
• “Hey, maybe we should have greater transparency into the diversity black-box”
• “Hey, maybe we shouldn’t make conservative viewpoints verboten”

Without spiraling off into “but but but muh soggy knees”, any reader should be able to look at those conclusions and say “Those are pretty reasonable things to consider, we can have a productive discussion about them even if we disagree”.

The fact that we can’t do so, because people immediately zoom off into talking about institutional bias and pseudoscience and namecalling and so forth, should be alarming to you. It is alarming to many of us, but most of us are keeping quiet having seen both the attacks on that person and the tacit support in our industry for those attacks.

You’re going to get upvotes, of course, because the rot is clearly set in even in this community but that doesn’t make your statement factually accurate–not that that matter anymore in public discourse. ¯\_(ツ)_/¯

For the curious, it turns out that this is just below the IRS’s $600 threshold which would require you to file a 1099 form for the payee. (They are still supposed to report the income, though.)