Obviously this is somewhat opinionated, but…

Powershell, IMO, is a very powerful shell. Its object model provides for quite reliable scripting, and the way it exposes many aspects of the Windows system makes it very useful for system administration. At work we have a requirement to do this type of administration, and it’s the right tool for the job there. As a developer who’s primarily after an interactive shell though, the benefits aren’t readily apparent (my compiler, editor, revision control etc are not Powershell commandlets) and it’s rather verbose/cumbersome.

Cygwin/msys are useful tools for people who want to use Windows but have a fully Linux-oriented command environment. I say “fully” because integrating Windows tools into a Linux toolchain is a little clumsy due to their different semantics - eg., direction of path separators, which component does wildcard expansion, migrating environment variables between the two, etc. Obviously there are ways to do interop, but using one of these shells to invoke primarily Win32 processes doesn’t seem great.

So the short answer is that just due to where I am, I’m a developer using predominantly Win32 native code tools, and neither of the above options are really optimal for that. Cmd is just ancient; Yori trying to rethink what a native Win32 shell would be in this decade, and heavily borrows from Linux shells but implements it with a view to invoking native Win32 tools. Some day I probably won’t be a developer working on predominantly Win32 native code tools, and when that day comes, Yori will be a lot less interesting/useful to me. I mean, I certainly don’t see any point porting it to other platforms, for example.

“we haven’t even seen anything like the one language to rule them all. “

That’s exactly what the LISPers always said they had. Their language could be extended to do anything. New paradigms and styles were regularly backported to it as libraries. It’s also used for hardware development and verification (ACL2).

Thinking more, you are definitely right that it may be super awkward to do anything tricky, but the code embedded in a peg parser would still help make things compact.

I have Factor running in production. Although I don’t really maintain the web app much - it just ticks along - Factor runs tinyvid.tv and has for the past few years. I originally wrote it to test HTML 5 video implementations in browsers back when I worked on the Firefox implementation of video.

As always, it depends on what you’re doing—I’d definitely be nervous if you told me you were shoving Factor into an automobile, for example—but Factor the VM and Factor the language are both quite stable and reliable. On top of doublec’s comment, the main Factor website runs Factor (and its code is distributed as part of Factor itself for your perusal), and it’s been quite stable. (We do occasionally have to log in and kick either Factor or nginx, but it’s more common that the box needs to be rebooted for kernel updates.) I likewise ran most of my own stuff on Factor for a very long time, including some…maybe not mission-critical, but mission-important internal tooling at Fog Creek. And finally, we know others in the community who are building real-world things with Factor, including a backup/mirroring tool which I believe is being written for commercial sale.

The two main pain-points I tend to hit when using Factor in prod are that I need a vocabulary no one has written, or that I need to take an existing vocabulary in a new direction and have to fix/extend it myself. Examples are our previous lack of libsodium bindings (since added by another contributor) and our ORM lacking foreign key support (not a huge deal, just annoying). Both of these classes of issues are increasingly rare, but if you live in a world where everything’s just a dependency away, you’ll need to be ready for a bit of a change.

You can take a look at our current vocab list if you’re curious whether either of the above issues would impact anything in particular you have in mind.

My non-breezy answer is “anything you enjoy using it for.” There are vocabularies for all kinds of things, ranging from 3D sound to web servers to building GUIs to command-line scripts to encryption libraries to dozens of other things. Most of those were written because people were trying to do something that needed a library, so they wrote one. I think the breadth of subjects covered speaks well to the flexibility of the language.

That all said, there are two main areas where I think Factor really excels. The first is when I’m not really sure how to approach something. Factor’s interactive development environment is right up there with Smalltalk and the better Common Lisps, so it’s absolutely wonderful for exploring systems, poking around, and iterating on various approaches until you find one that actually seems to fit the problem domain. In that capacity, I frequently use it for reverse-engineering/working with binary data streams, exploring web APIs, playing with new data structures/exploring what high-level design seems likely to yield good real-world performance, and so on.

The second area I think Factor excels is DSLs. Factor’s syntax is almost ridiculously flexible, to the point that we’ve chatted on and off about making the syntax extension points a bit more uniform. (I believe this branch is the current experimental dive in that direction.) But that flexibility means that you can trivially extend the language to handle whatever you need to. Two silly/extreme examples of that would be Smalltalk and our deprecated alternative Lisp syntax (both done as libraries!), but two real examples would be regular expressions, which are done as just a normal library, despite having full syntax support, or strongly typed Factor, which again is done at the library level, not the language level. I have some code lying around somewhere where I needed to draft up an elaborate state machine, and I quickly realized the best path forward was to write a little DSL so I could just describe the state machine directly. So that’s exactly what I did. Lisps can do that, but few other languages can.

The threads are still green threads, if that’s what you’re asking, but we’ve got a really solid IPC story (around mailboxes, pattern matching, Erlang-style message passing, etc.), so it’s not a big deal to fire up a VM per meaningful parallel task and kick objects back and forth when you genuinely need to.

In terms of future directions, I don’t know we’ve got anything concrete. What I’d like to do is to make sure the VM is reentrant, allow launching multiple VMs in the same address space, and then make the IPC style more efficient. That’d make it a lot easier to keep multithreaded code safe while allowing real use of multiple cores. But that’s just an idea right now; we’ve not done anything concrete that direction, as far as I know.

Really off-topic, but isn’t Slava at Apple?

Traveling between companies as a group of friends doesn’t mean that you’re only working with said friends, since there will almost always be other co-workers involved, but that you’re working with more known quantities. As an employee-side strategy, I don’t think it’s hugely problematic, especially given the amount of information asymmetry that’s often in play in hiring. I’ve also had luck with referrals (I’ve found out about 3 out 4 of my development jobs via some sort of reference or connection, including my current one).

On the employer side, I could see only working with referrals being somewhat problematic, but I doubt most employers do that.

I mean, my friend’s friend who I am now working for is roughly 3000 miles away from where I met my friend. I was definitely exposed to diverse perspectives by moving out here, and I necessarily have to interact and learn from all of my new coworkers (who are all diverse strangers to me). What I gained was a pre-selection stamp; somebody vouched that I’m not an idiot.

It’s also bi-directional preselection. I know that my friend wouldn’t send me off to work for a real dumpster fire of a company - I know that I’ll be working with good people on good projects, and it would benefit my own personal growth.

Friend networks can span multiple cities, countries, companies, and cultures. It doesn’t have to imply inbreeding.

The words that come to mind are exclusive and cliquish.

This sounds fun in practice until you hire a terrible stranger. Then you’re back to square one of “how do you find out if an interview candidate is good?” And it’s a hard question.

Duclare, using ssh instead of SyncThing would certainly work since the database is just a file.

Ideally it’d be automated and integrated into the password manager though. Keepass2android does support it, but it does not support passwordless login and don’t recall it ever showing me the server’s fingerprint and asking if that’s OK. So it’s automatically logging in with a password to a host run by who knows. Terribly insecure.

I had the same situation. 3 conflict files and merging is a pain. I’ve switched to Pass instead now.

You can actually have it for free. They have an open source GPL version at https://livecode.org/, it is targeted at professional developers but I know a ton of non-developers using it (I used to be a quite active member of their community) and techers in K12 space using it as well so you can still have that feeling of using stacks in HC.

I always use it when I need to transform data for some other stuff I am doing, or to scrape stuff for personal use, or to do some form of batch processing.

A recent example, I was building a little API backend server for a project that is not related to LiveCode, just normal web stuff. It was easier for me to cook up a little stack with buttons, fields and some diagnostics and debug my little server while I was building it than use those generic tools such as insomnia.

Those generic tools are awesome, pretty and powerful, but my own handmade tools, which I create specifically to a given project have the advantage of being tailored to whatever I am building, so they might be ugly but they are my special-purpose tools that help me develop and debug my own projects. There is a lot of developer ergonomics when you can quickly come up with GUI tools to debug whatever you’re doing.

Another example is when I had to do some complex batch renaming of thousand of files. The process involved a little crawler going on disk into the folders, inspecting some configuration files relative to the folders and renaming stuff inside them. I could do this with visual feedback, progress bars, etc…

I am quite bad at design but I am scratching my itches, not selling itch scratchers. My little stacks help me a lot.

What the hell, @rain1.

Find something kinder to do with your time.

Bringing other people down while adding nothing to the conversation isn’t something we need here.