yumaikas

If you're a CTO, why are you building out features, if I may ask? Shouldn't most of that be delegated to devs under you?

In any case, it sounds like you might need to try to find a community of folks to help mentor you, and act as sanity checks? At least, that's my thought.

Though with everything that's happened in the last two years, it may just be burnout, in which case rest is probably the best approach.

I mean, `npm donate` is a thing, I'm pretty sure. Just need to build it for other ecosystems.

It's funny how the particular constraints of a system can matter in different ways the designers didn't have a solid handle on at first.

I could see an argument being made for 'fake 3D' pretty strongly here. DF Retro has a few videos comparing various consoles, and one of the things that the PS1 and Saturn both got wrong, IIRC, was that textures would warp*, because the 3D look was being provided by affine transforms (as I understand, I may be misremembering the details), rather than perspective correct rasterization.

So, like, the vertexes are in the right spots, but the texture mapping is off. So it kinda depends on if you need texture mapping to be perspective correct to consider a given example of 3D "real" vs "fake". Dark Forces also has perspective warping that happens in it's engine when you look up/down, as an example.

* https://youtu.be/VutzIK3DqZE?t=341 DF Retro analyzes ports of Tomb Raider

For me, I switched over to Powershell Core, and as far as I'm concerned, it's way more productive for building situated software than the same gaggle of scripts that one gets with bash, in most cases.

param statements get you auto-complete, and docs. Powershell can just ingest and deal with JSON, and are one module away from doing the same with YAML.

Using % and ? (aliases for 'Foreach-Object' and 'Where-Object') ends up working very well for most data manipulations that one might be interested in.

It definitely has it's quirks as a language, but so does literally every shell in remotely common use.

And I'd say that Powershell is appropriate for non-trivial scripting use, as long as you familiarize yourself with the conventions for handing data to/from functions vs pipelines.

I've written more than one piece of above ad-hoc software in Powershell, though this is the only one I have in public: https://github.com/yumaikas/psi.

> A line of LINQ looks and works nothing like a line of C#

Maybe if you're using the query form, but if you're using the method form, I'd argue that they work together very nicely.

For me, at least, I've found embracing Lambda expressions to be very helpful in a number of cases, between Linq, or writing my own code for doing things like rendering tables (long story there).

Granted, I learned C# right after LINQ was released, but I'd still argue that LINQ is well worth having around.

If there are other parts of your life that are negatively affected by this, you (and the person you're replying to) might want to look into ADHD.

But I can also relate to never wanting to stick to one system for second-brain work indefinitely.

I've made the mistake of trying to build my own second-brains more than I probably should.

On windows, there are APIs for setting color that could be ignored if STDOUT isn't a terminal.

On posix platforms, there's an API to check if a given file handle is a tty or not. https://github.com/corasaurus-hex/isatty/blob/main/isatty.c is an example of using the API, in a Janet context.

I assume that .NET's support for Linux/macOS is using that API decide if it should strip color codes or not.

The ecosystem around C and C++, existing projects. C++ code is known to be able to build millions of lines of projects. IIRC, Crystal still struggles there, though I think the last year has had improvements there? To be fair, C++ does as well, but how it struggles is better documented.

I'd bet that C++ gives you more low level control than Crystal does, though I'm not deeply familiar with Crystal.

Zig and Rust both seem to eat at the space that C++ occupies more than what I've seen out of Crystal, but I have not followed it closely at all, so I could well be wrong there. Crystal feels closer to the Ruby flavor to Nim's Python flavor, and I know syntax doesn't imply low-levelness, but yeah.

I'd be very heavily interested in how much things like ADHD affects that media-multitasking bit.

I mean, I go and set up ASCIIQuarium on every phone I have. Hunting down the APK gets harder and harder though.

When I think of destructuring match, it's not just about destructuring, but also about matching a set of clauses against the matches.

I rely on the imperative parts of Janet less than I used to, but yeah.

I am surprised that no one has tried to build something like Sinatra for Clojure. From what I can see, nothing would keep Clojure from being able to make something like that.

That is true, but to engage in a bit of semiotics: those cores are hardly the most appealing part of Lisp for most of the uses cases it's found. It certainly was one way to enable the interactivity and homoiconicty and metacircularity, but, as Clojure and Janet demonstrate, there are a lot of other aspects of Lisp that have value. And while one could (and some have, IIRC) built a Lisp on those minimal data structures that doesn't have parens, most people associate Lips with them being in the strange place.

Cons/car/cdr are far less important, IMO, than eval.

Read, on the other hand, is also technically missing from Janet, and I personally don't mind a great deal, but I could see that being argued.

One thing I find funny/curious: Does clojure not have a destructuring match in it's standard library? Most people that I've seen move from Clojure to Janet seem to avoid using that.

For me, the two types of programs I tend to use to exercise an language early on are small CLI programs that help me free up mental space, and web apps. Clojure, outside of babashka seems ill-suited to the first (and I've not figured out how to get the CLR clojure up and running).

And when I last tried to do web apps with Clojure, it seemed like everything relied on a lot of self-assmebly, and didn't map cleanly to ways I knew how to web apps at the time from Go, C#,or Erlang. I dunno what the situation is there these days.

For Janet, I did lean into the more imperative constructs early on.

The other really pleasant aspect of Janet is that it easily enables build fat-image executables. Asset packing is as easy as a top-level

    (def asset (slurp "file.txt"))

This makes it a lot more at home on Windows than Python or Ruby on that respect, IME.

My impression of Janet is that it's threading a needle there.

The core is still heavily meant for embedding. It's not as light as Lua, but there's an amalgamation .c and .h, you can strip out everything that depends on an OS underneath, and so on.

That being said, a lot of folks that use Janet and are in the gitter/matrix server are currently focused on aspects of web dev, myself included. Lisp, as always, enables a lot of expressive power there that enables building your own pieces of the web stack, for example.

C bindings are relatively easy, and use the same interface that is used to build the standard library, so performance doesn't really take a hit from the interop code.

I can't speak to the GC, other than to say that it hasn't been an issue for me yet.

What's funny is that I came up with a half-decent acronym this morning: PAST.

Paren AST languages.

But this article has been sitting in a draft for the better part of a month, lol.

Clojure was something I tried once or twice, but couldn't quite get into, at least back when I tried it before.

These days, I might be better able to pick it up, having cut my REPL teeth on Janet.

JPM is a tool distributed alongside Janet that will download deps for you with `jpm deps`.

Oops, that was not an intentional spelling.

So, what makes this fundamentally different from something like an insulin pump?

The performance problems, at least, have had some TLC applied to them and are much better in PowerShell core (the one that goes by pwsh), to the point that I don't hate using PowerShell interactively now.

The grind is eternal, so adjust your pace accordingly, IMO.

I do think that many orgs don't have any sense of pacing when it comes to software dev. So, don't set expectations too high for an org if they don't have PTO in place to compensate for hard work.

Nim, Elixir, Rust, Zig, D and Jai would all like a word.

For me, Janet seems more practical than Racket, or I at least got over the hump of it better. I like Janet's function-like data structure access as well, I don't know of another Lisp-like that does that.

Mostly just time and testing coverage, and more packages for various things. Maybe another 10,000 man-hours? I don't know the exact numbers.

For context, I've found and/or helped fix bugs around multi-char string split, process termination on windows, and async IO on Windows. All things that forced me to pop the hood on the language, study relevant OS APIs, and generally yak shave, rather than focus on the task at hand. Which has been really edifying, but would have slowed me down if I was writing for a job.

In the process, I've written a few libraries of my own for things like string manipulation, data schemata, rendering html forms/tables based on a schema, and so on.

If you have people that are competent with C, then Janet atop that could work well, but by itself, it's still a long ways from having all of the things one might expect from Python/Ruby, let alone Java or .NET

It is little weird, but it's also really fun to work with, if you're doing things that don't need to ship yesterday.

Working with Janet has deepened my knowledge of the Win32 APIs, for example, because it makes writing small bits of C for interacting with them about as easy as that can be.

I also like how it makes data structures and functions look the same in terms of access, and how it handles nil.

Janet's biggest draw for me was it's PEG engine and API. That is still excellent.

But I'd say the biggest draw for me now is that Janet has a lot made a lot of choices I agree with.

It's language that boots up very quickly, makes for easy building of CLI tools, compiles to statically linked executables, has full compile-time metaprogramming (Lisp style), and can interface with C libraries very easily.

It doesn't solve any particular novel problem better outside of PEGs, but it makes a lot of the right decisions. And, being a Lisp-like, it also gives enough expressive power to help you build things your way, if you want.

Most of that probably appeals to folks who a) have been programming for a while b) don't hate parens c) Are ok forging in untread territory

Janet isn't something I'd build a business on, not quite yet, but it has been a very, very satisfying hobby, and I've written a lot of small tools in it, more than Nim or Go during my times with either of those.

And have the spare resources on hand to be able to survive repeated failures, for that matter. And not be dealing with ADHD or other mental issues.

In the back of my head I want to tease out how much of Beso's success is due to aptitude, how much is due to work, how much is due to privilege, and how much is due to luck, and how much is due to ruthlessness.

This might be a futile exercise, all told, but I do think all of those factors have played into his success.

And I wonder how his success and the other factors compound in the perception people have of him.

Lots of people with power shut down people who are smarter than them for being annoying, I guess is what I'm getting at.