Indelible Blue Pen

Jason C. McDonald (CodeMouse92)

January 23, 2018

A Trendy Article From 2048

Thanks to a glitch in the time-space continuum (which apparently operates on C code, who knew?), I accessed the following article, written by some random coder, from a version of 30 years in the future.

The most interesting part to me is the comment section on that article. Just goes to show you, the more things change, the more things stay the same.

Disclaimer: Don’t take this as advice on how to be ready for the coding world of tomorrow! This article is from the future. All it would take is one person sneezing at an inopportune moment and scaring his girlfriend’s pet chihuahua to completely alter the trajectory of time, whereby none of this happens.

Taking a Look at Corundum 2.0

I recently downloaded the latest version of the Corundum web framework. In the past, I haven’t been terribly impressed, as the documentation is pretty dense, and I’ve been pretty decently happy just hand-rolling my own JK++ code to get the job done. But I have to admit, once you work your way past the learning curve, Corundum makes life soooooo much easier.

Of course, there are hundreds of frameworks for making apps that work over the subether interlink, but in my opinion, most of the holographic interfaces people make with them still look like those dusty Javascript web apps from the 10s (flat colors? Who does that anymore? Srsly….). Corundum interfaces really look modern.

Of course, Corundum still has its detractors. Some cite the fact it can suck up RAM really fast, but I don’t see that as a problem. If you’re running a computer with any less than 8 PB of memory (and a 2.5 THz processor, while we’re on the subject), you should think about upgrading that dinosaur. ;) So, while a “Hello, World” app in Corundum is going to chew through about 200 TB of memory, that’s a small price to pay for a clean, modern interface and the latest features.

Another common argument against Corundum that I hear is that it “automates too much.” I’ve run into a number of old-school troglodyte coders that insist that explicit is better than implicit, a saying borrowed from Python, Go, Rust, or one of those other dusty old languages that don’t really have a use other than “legacy support”. (It’s almost as bad as the financial sector, which is STILL using COBOL of all things.)

But I digress, before this turns into another “seriously, why are you still using ancient languages like Go” articles. Don’t knock those old languages too much; most of those languages still have a place, even if they’re painful to work in. After all, Linux is still written in Rust, and it works great despite that language’s terrible error handling.

Anyhow, I think the saying ‘explicit is better than implicit’ is way out of date now. After all, any decent IDE is going to record what you were thinking about when you designed the code, so you should be able to figure it out pretty quickly later. Corundum’s intention-resolution support is excellent, and I rarely get ambiguity errors.

For coders coming from less intelligent frameworks, it will take some time to get used to letting the computer resolve ambiguity for you. For the sake of keeping code brief, Corundum actually doesn’t allow you to explicitly resolve anything in the source. If it gets confused, which (again) is rare, it’ll just prompt you to clarify. Once you’re past the phase where this blind trust gives you heebie-jeebies, you’ll find you code a lot faster.

A few benefits I’ve found in using Corundum:

  • Great integration with RERUN databases.

  • Supports the latest mindreading protocols, including Orwell, SpeakMind, and TaNK.

  • Great compatibility with all the architectures…unless you want to use something crazy antiquated, like Intel or AMD processors.

  • Supports full-color holographic interfaces! (Something I couldn’t find in the other libraries.)

Now, I know that Corundum might not work for everything. I’m still a strong believer in being able to code without a framework. JK++ is a really capable language on its own. But if you’re able to put in the time to learn Corundum initially, I think you’ll find like I did that it saves a lot of effort in the long run.

Comments Section

  • Explicit IS better than implicit. You’re still wasting time reviewing your automatically-recorded thoughts when debugging.
    • who doesn’t use ai for debugging these days? my prof says theres no reason not to
    • Uhm, in practice, ai debugging doesn’t catch a lot of logic errors still.
      • logic errors? what is this, functional programming or some old paradigm like that?
      • …all coding paradigms get logic errors. o.O
    • I lost track of the number of times my AI debugger couldn’t find the problem. Desk checking FTW.
      • One more reason I still like old languages. Those manual debuggers rocked. I think someone ported gdb for JK++.
  • You think Corundum’s docs are bad? You should see some of the old UNIX man pages. Of course, by saying that, I’m showing my age. (No, I did not personally know the dinosaurs.)
    • 20 years, and they still don’t know how to write good docs. You’d think the mindreading technology would have helped, but nooooooooo.
  • D’you suppose they might port Corundum to work with the Leaf programming language?
    • I think that’s up to Leaf’s BDFL, honestly.
  • clean code shouldn’t have a lot of inline thought recordings, because they really confuse the whole thing. one solo open source project i found on github had a bunch of random thoughts about cheese scattered throughout it.
    • emacs can clean up your thought records, you know. C-x-relevant
    • Real coders use vim.
    • omg u use github still?? i didnt even know that was still around
    • yeah, it’s mostly legacy code, but it’s got some cool stuff if you don’t mind the interface.
      • i could never get past the interface. IdeaDrop for me, girl.
  • Hey, I still use Python! It’s a great language.
    • Yeah, I guess, assuming you can wrap your head around that clunky import statement and other such clunky stuff.
    • It’s still better than how C++ did it. #include "somefile.hpp. Ouch. Just ouch.
      • C++? LOL, I haven’t heard mention of that since college. I think my grandpa has a book on C++17 around. Ancient history, yo.
    • I still can’t believe the #python IRC channel is still there! Bunch of troglodytes.
    • Be nice. They do a lot of low-level stuff so we can work with modern languages like Narf and JK++.
      • Yeah, yeah, okay.
    • I can’t believe IRC is still there.
    • Wait, what’s IRC?
    • Y’know, Python 18.7 ain’t half bad. Doesn’t even feel like the same language.
  • Corundum is okay, but I like FooUI better for interfaces, and that’s supported full-color holographic interfaces since v1.3.
    • FooUI?? Isn’t that, like, for Nim?
    • Originally, but they have bindings for JK++ now.
      • Oh, cool, good to know. I liked FooUI back in the day.
    • Nim’s still better than Javascript.
      • Dude, anything is better than Javascript. JS = pain, as they say.
  • Corundum is just a fad, like blockchain, neural networks (the original ones, anyway), javascript frameworks, and cloud computing. Use it, but don’t get too dependent.
    • Nah, Corundum is solid. It’ll probably be in use in 20 years still.
    • That’s what they said about javascript frameworks……

Leave a Reply

Your email address will not be published. Required fields are marked *