sifoobar

The more I learn about interpreters and compilers, the more everything looks the same.

Snigl [0] is designed as a VM interpreter. But it has a separate compile stage where code may be evaluated using the same interpreter and the results reused at runtime.

And it traces code before running it, evaluating as much as possible statically.

Finally, it supports emitting C code for an interpreter preloaded with the current, traced program. Which is where compile time evaluation really shines, as the results are embedded in the executable.

[0] https://gitlab.com/sifoo/snigl

I agree; and there's nothing wrong with not wanting to deal with that level of complexity and hair pulling, I don't blame them.

I don't mind Rust either; it doesn't appeal to me, but then many languages don't. If it helps someone move forward, that's a good thing.

What isn't working very well is having Rust stuffed down my throat while being lectured by ignorant assholes who don't even know which side is up. That's going out of fashion fast.

Evidence? I have my own authentic experience, if that's not good enough for you it's really your problem.

I suggest learning C properly before you make more of a fool out of yourself. It's more constructive, too; because it actually improves your situation. Right now you're just digging a bigger hole.

Programming is difficult, writing kernels even more so; hence there will be bugs. It's not a language issue.

The problem is that by the time it's warmed up enough to actually run as fast as advertised, the world has already moved on. And when it still doesn't, figuring out why means digging through a giant pile of complexity that you didn't ask for. Thanks, but no thanks; I wasted enough years on Java.

Programs have bugs, period.

Some of us have been around long enough to see the pattern, go back 15 years and you'll find me preaching the same gospel in the name of C++.

One thing that would help is to stop dumbing down programmers and languages, and start valuing experience and powerful tools again. The full stack developer role is a joke, and not a very funny one.

True, and False.

You're projecting your own experience.

I have a pretty good idea what decent C looks like, as does anyone else who spent 30 years using it.

I wish more so called experts and professionals would put serious effort into meditation and/or quantum physics.

There's plenty more to consciousness than statistics and pattern matching, self awareness is a big one; and adding more layers of the same and/or curating better data sets isn't going to solve the problem.

Of course there are limits, it's statistics and pattern matching and has very little to do with intelligence. Not to speak of risks, since it will keep failing in surprising ways and never be able to explain why.

I wish this was a joke, but here we are. Luckily I have a better alternative for you; find a meaningful physical activity that you enjoy doing instead, and sit back and watch your priorities take care of the rest.

I have a wooden man [0] and a sand bag in my living room, which means the barrier to training is basically non-existing. And its a kind of training I enjoy, because it leads somewhere and strengthens the body in a non-artificial way. I'll do five minutes here, ten there; with the occasional late night 2 hour session.

https://www.youtube.com/watch?v=tSbUoSxee0I&t=21s

I often sum that up as follow your heart, however worn out the words may be.

Anything less leads in circles, and that's usually not the goal.

If there was another way, someone would have found it by now.

Produce what, exactly?

Because anything beyond pushing a button N times per hour is going to benefit from experience, and it gets more important with task complexity.

I would much rather have someone with 30 years of experience writing code I depend on than a 20-something who can type 10 times as fast.

Snigl [0] traces the code before running it; simulating stack contents and inferring generic calls based on that information as far as possible, among other things.

It's not perfect, but it's the only way I've found that makes sense in combination with Forth-like stack semantics where function parameters are never specified explicitly. And that runs fast enough to make sense in an interpreted language. I also like that it's implemented as a transformation on VM code, which makes it flexible and easy to debug.

[0] https://gitlab.com/sifoo/snigl#tracing

Metoo, don't have that many options lately for health reasons. So I figured I might as well use the opportunity to have a go at the status quo.

Nailing the future down to worst case scenarios isn't very constructive from my experience, visualization is a powerful tool and cuts both ways.

It's not sustainable right now. But predicting the future is a fool's game, everything changes all the time and no one really knows anything for sure.

Try to picture where you want to go instead, it's more challenging but at least it has the potential to lead there.

And good luck to us all :)

I started writing my own embedded scripting language [0], based on Forth and Lisp rather than Lua. Besides being easy to embed, there's not much in Lua worth keeping if you ask me.

[0] https://gitlab.com/sifoo/snigl

One issue is that we're encouraged from every angle to make fun of those challenging the narrative; which is very effective in discouraging people from doing just that, especially after having taken part themselves.

The reason it's fast is brutal simplicity. But it's a spectrum, with dogmatic Forth close to one end; the more you can keep things simple, the more raw speed you get for free.

The approach I'm using in Snigl [0] is to start with Forth and add more elaborate features as optional/gradual layers. As long as you don't use variables and closures you get to enjoy more raw speed etc.

[0] https://gitlab.com/sifoo/snigl

You can't separate human behavior from environment, period.

They've found genes that sort of predict violent behavior, but only if the person carrying the gene is subjected to abuse; which means that the gene probably predicts higher sensitivity to abuse rather than a violent nature.

You're pretending that labeling some people evil because they have the wrong genetics is a solution, it isn't.

You're forgetting that everyone who came to the same conclusion as I did had already been where you are, we all walk more or less the same path.

I'm not saying everyone is the same, far from it; there wouldn't be any need to keep billions of us around if we were.

But life doesn't waste opportunities for evolution, and there's no point in having billions of people watching Netflix forever. It will find a way to get you out of your comfort zone, cooperating or kicking and screaming.

I find it's a bit like navigating using GPS, once I get there I still have no clue because I was mostly acting on cues.

Slow compiles have the same effect for me, I get pushed out of flow and into reactive mode.

The only way to write good code is to be proactive, and any features that interfere with that process are worse than whatever "problems" they "solve".

Snigl [0] leans more towards multiple dispatch and Lisp than OO and Ruby, but I figured it might me interesting anyway if you've been thinking along those lines.

[0] https://gitlab.com/sifoo/snigl

It's a shame Forth is so tricky to find. I learned Prolog and Lisp in school, but Forth was never even mentioned. It would make an excellent introduction to programming if you ask me.

Once I got my hands on a tutorial, I quickly realized it was the perfect foundation for the language [0] I've been designing in my mind.

[0] https://gitlab.com/sifoo/snigl

Me neither.

I did use it religiously for a long, long time; then tried without for a week and never went back.

It's not like telling the difference between string literals and keywords was ever a major issue for me. I guess it could help short term when learning a new language, but I'm pretty sure it slows down overall progress.

You're not going to save the planet by not having kids, I know that much. And maybe that's exactly what they bring here, enough new perspectives to get through our issues?

It's not about being happy, happy comes and happy goes; it's about doing something meaningful with your life, because it's the only thing that is going to work long term.

We do have some kind of shared understanding when it comes to humans though, especially within a culture and even more so within a limited context like driving a car.

We don't generally expect someone to freak out and start treating a car in sunlight as a house because they've seen a lot of houses in sunlight lately.

The difference between a human and ML is that a human has a clue, demanding perfect introspection is missing the point.

This borders on dishonesty if you ask me, he should know better.

Thank you.

Have you considered the fact that practically everyone who commits these kinds of crimes had similar things done to them; often as children, often by relatives?

Everyone is responsible for their actions. And some people have a long way to go to before they've healed their traumas. But pretending that some are evil and others are not isn't solving the problem.

It would be more constructive to ask what can be done to prevent people from becoming this messed up, children from being treated so horribly etc. And how to best help people heal and take back control over their lives.

Maybe you're looking in the wrong place?

The question on my mind is the following: How is blindly trusting science better than blindly trusting the pope or your local shaman? Wasn't the real issue blind trust, rather than who or what?

There's nothing to be afraid of, and no reason to take a stupid test. I had to as part of drafting and I can't see these tests leading anywhere worth going. Maybe ask why being seen as smart is important?

I don't buy the idea that we have to pound the crap out of each other in a ring to prove that everyone is honest about their skills.

If you want to learn anything, you definitely need to spar; but sparring is not a competition, no one is actually trying to hurt anyone. The more experienced your partner is, the harder you can go without risking injury.

TKD suffers from the same sports virus as MMA if you ask me; just a different, less violent and more exotic flavor.

Every coder should if you ask me; I consider C, Forth & Lisp to be the brightest shining stars in PL design. Each of them offers a unique approach cut down to it's core. If you prefer a more convenient and less dogmatic approach, I'm working on a hybrid scripting language [0] that might be of interest.

https://gitlab.com/sifoo/snigl