codr4

Second most of that.

I used to be really passionate about C++ back in the days, but it's just too damn complex. Yes, some new features really help; if I could bring one to a desert island it would be lambdas. Tuning C++ these days is mostly trial and error for me, there are so many gotchas to keep in mind that it's more or less impossible to juggle it all mentally.

From my experience there comes a point where the required effort tips the scales towards more convenient languages for most projects. But by the time you realize you're usually up to your neck in template goo that no one wants to translate.

I would submit an entry for my own project, Snabl [0]; but it intentionally doesn't support the algorithm since naive recursion beyond a few levels doesn't make much sense in practice. I added a separate keyword to force tail calls since that's usually what you want.

[0] https://github.com/codr4life/snabl#function

Haha, wheretf did all the users come from :)

A nice problem to have if you ask me...

So you're saying never use recursion? Or never benchmark it? I don't get it, it's a tool; a pretty good tool when combined with tail call optimization. Yes, the algorithm they use is naive; I believe that's part of the point.

Different machine and superior algorithm, where are you aiming with this?

Thank you for that, I need more bewilderment like I need another hole in the head.

Next!

I've tried to explain this to one of my (former) employers, he just couldn't wrap his head around it.

Of course it matters, I paid a fortune for whatever. Yeah, right.

It's really about being here and now, and may be applied to anything in life.

Same here, I couldn't bring myself to contribute to the current drama for all the money in the world. This crap has to crash an burn first, then I'll be more than happy to help create something better. While I'm waiting; I'm writing the code I always wanted to write just the way I feel like [0].

https://github.com/codr4life/snabl

Static/dynamic is obviously a gradient. I find it a bit sad that it always seems to be either or these days, either no types or a full blown static generic type system.

I'm all for the ability to type variables and functions, as long as I'm still allowed to be exactly as precise as I feel like.

Many would call that static typing, since there are types in the code that the compiler consumes. But my own attempts [0] at building such languages tell me that the result is still more dynamic than most.

[0] https://github.com/codr4life/snabl

Laurency's The Philosopher's Stone is one I'm sure about, fairly certain I read the same thing in Blavatsky's Isis Unveiled. There are more but it's been a long time and I don't have the books available now.

Is it really that difficult to imagine? There are all sorts of traces and stories about more advanced civilizations before ours, and more advanced beings than us. As of talking monkeys, people with bird heads and feathers and so on.

I'm with Socrates, I don't know anything for sure about this world. What I do know is that the pieces we've been handed don't match up with my experience.

Depends on the kind of software, though. If you're writing an interpreter/compiler, web server, database or operating system you don't have much choice.

There are several reasons, and this list is far from complete:

Hemp threatened the cotton industry.

Cannabis was more usual among Mexican immigrant workers, which is why they renamed it to something more Mexican sounding.

It was a convenient way of breaking up the hippie movement and avoiding Vietnam war protests.

It has many medicinal uses and less side effects than the artificial crap we call medicine these days.

It scrambles the programming, people start asking themselves the wrong questions when using it.

It allows the government to conduct a war against its own people, and discriminate freely; while claiming to protect.

And on it goes...

States have managed to foment different levels of social stigma.

In Sweden, where I was born; you might as well do crack cocaine in most peoples eyes.

The wheel of pain and suffering must roll on, otherwise people might get a clue and unite against their oppressors.

Or in the words of the freemasons, order through chaos.

Once hurt, few seem to have enough integrity to break the loop; so it snow balls nicely all by itself.

So how is trusting authority working out for you so far? It's a piece of the puzzle, these stories come from somewhere. The general idea is to use your brain to put the pieces together.

Many occult texts claim that the monkeys of today are a result of back crossing human DNA into monkey species long, long ago; and that they have been in regression ever since, turning less human with time.

I'm sure it can, but it takes longer and works differently than we like to believe.

Empathy, sensitivity -- the ability to connect to other people on their level and feel what kind of nudges they need to evolve.

But of course you can't expect that to happen if you treat teachers like garbage and stuff them in sterile rooms with 30 over stimulated kids.

Been there, done that; went through hell to get off OxyContin after a climbing accident.

Repeat customers are created by doing long term harm while providing short term relief, expecting corporations to actually solve problems or have a conscience is beyond silly.

I've done more Yoga than most and suffered from chronic pain after a climbing accident for a long time. The reaction to pain makes a big difference, and it's very difficult to react in a sane way when your ego is left running the show while you're out time traveling.

Loosing your mind is not as bad as it sounds.

My Yoga teacher used to remind that a mind full of crap is not very useful.

It also puts the focus on letting go, which is key to making progress.

Not that I notice any more, took me about a year for everything to settle though. What really helped me (and people will think I'm crazy, but here it goes), both mentally, emotionally and physically; was Yoga. The real deal, not the hipster kind.

Carrying heavy things and performing unpredictable, physical activities changed. Recently tried surfing for example, but since I can't control the motions enough to protect my spine and the price for a mistake is so high it takes the fun out of it. And I stopped climbing for mostly the same reasons.

One day at a time, you'll be fine :)

Living is dangerous. I was told I was very, very lucky to be alive.

I had three vertibrae fused similarly ten or so years ago after a climbing accident smashed the middle one into pieces. Many days it doesn't even cross my mind unless I have more pain than usual for some reason; but now and then I realize how surreal it is to have those pieces of metal inside my body, and how much my life has changed as a result.

Definitely a near-life experience, wouldn't change it for anything in the world; but you can't really go around and recommend people to fall of cliffs.

Lua is written in C, which is a very different language these days.

Snabl uses the C++ standard library all the way through, which leads to a tighter fit in C++ applications.

And I have enough issues with some of Lua's design choices to rule it out either case. Everything is most definitely not a table and I want an expressive, generic and gradual type system built in.

I'm not that fond of fancy strings myself, or things like CL's LOOP macro. I prefer real code with composable abstractions. The problem in my mind is that they're not integrated into the host language, and therefore don't compose well with the rest.

But that being said, using a simple embedded glue/scripting language that's fully integrated into the host environment makes a lot of sense to me. Emacs Lisp, Autocad, any game engine etc. It's a tried and proven strategy.

I started writing my own glue language [0] for C++ since I couldn't find anything simple and integrated enough for my taste.

[0] https://github.com/codr4life/snabl

A full stack is one push from overflow, I feel that sums it up pretty well :)

Silly walks is a masterpiece, and people think they're joking...

"It is time to unmask the computing community as a Secret Society for the Creation and Preservation of Artificial Complexity." ~Dijkstra

It's very impressive work, no doubt. And as long as no one asks me to debug anything running on top, I don't have any issues with it.

At least with straight reference counting I know what's going on under the hood, that's worth a lot. Sharing pointers across threads is tricky business, I can't really see what that has to do with anything. And it's quite likely that it will run faster, simply because it's much less complex.

Sorry about the toes, but identifying with a programming language will always get you into trouble. My gut is fine, thank you very much.

They're C heads, trying to build a simplified C; at least they were, they sort of messed that up with garbage collection, wild west threading and using reflection for all the wrong reasons.

Sure, now the tone is different. But back in the days when the language was first released, they would make fun of anyone mentioning generics or exceptions.

From having spent quite some time in Amsterdam, I would say that you're safer on a bike than on foot. When a biker rings the bell on you in Amsterdam it's not a heads up or suggestion to get out of the way like in the rest of the world; it's quite possibly the last thing you will ever hear. From my experience, they go fast and expect you to move out of the way. Or you could try to not walk in bike lanes, I guess; not that I had much luck identifying them.

I have nothing more substantial than a gut feeling to back this up, but it all feels half baked and too conservative to me. Like they cranked out some special syntax and new concepts that sort of solve their problems and called it a day. It may look like the path of least resistance initially, but sooner or later the features will start stepping on each others toes.

That's about right. And gradual types, multi methods, generics and tight integration with C++: [0].

Dylan was too long winded for my taste, as are most modern attempts.

[0] https://github.com/codr4life/snabl