billrobertson42

It's easier to have your parents use a mac.

You're either realtime or you're not. If you have hard and fast time requirements to perform certain actions then you're real time. (e.g. 3 ms. to decide whether or not to turn the cruise missile or it hits a hospital). There is no 'soft' realtime.

"Java - Too bloated for me and if I use it there is a possibility Oracle might sue me!"

I hope the author was joking. That makes no sense otherwise.

This is not new. Fabrication was one of the factors leading to famine during the great leap forward. https://en.wikipedia.org/wiki/Cultural_Revolution#Great_Leap...

The text for the upper boxes is easy to read on the full sized png, but difficult when scaled when showing in the github page. If the smaller size is the default it could be an issue.

I also think you should make scales for "Used Memory" and "Memory Consumption" the same.

Looks good though.

I think the point is that most people will let you fumble around/meander until they understand or until you stop. Whereas an 'asshole' will simply tune you out otherwise.

I prefer early returns for precondition checking too. i.e. before anything interesting has occurred. Thinking about it though, I've just realized that the early-return problem is sort of a by-product of side effects. If your function simply takes input and produces an output, and you control where side effects are applied, then early returns are far less of an issue.

Cyclomatic complexity (CC) is good as long as it doesn't become the end-all be-all measure of code. I've run into crazy types that use it as an abusive bludgeon.

Code that has low CC feels strange if you're not used to it, but there are some good reasons to like it. One of the things that I find appealing to it is that by putting things into named functions, you're better expressing your intent by giving it a name.

C/C++ can be taken to extremes with preprocessor abuse. If you've never looked at the obfuscated C programming contests, then you should. As far as Scala DSL's go, didn't somebody post one the other day that made an ascii art picture of a Christmas tree into a valid scale program? Isn't there also a Scala DSL that lets you make it look like basic?

Sure, there are languages that don't let you get at the meta, but just because the ones that let you do can be abused does not invalidate the usefulness of the notion.

I wonder if he's looked at golang.

Just tonight I had to work on a code base that I initially wrote about five years ago. This is a working product that's been rock-solid for the client. Still though, at one point, I really hated the code.

Nevertheless, I've been able to extend bits and bobs of it over the years without major headache or breakage. And tonight I had to write a simple related utility program. I was able to grab various classes out of the code and just use them, or re-purpose them with little effort.

Are there issues with the code? Hell yes. I'm always learning as a programmer and I'm much better now than I was then. Does that mean the code was crap? It feels kind of hard to say this, but no it wasn't crap. It did the job and it hasn't been a maintenance nightmare.

So when you look at code you wrote 6 years/months/weeks/days/hours/minutes ago and think, that's total crap! Don't beat yourself up over it. It just means that #1 you care and #2 you have learned something between then and now.

Oh, and after looking at the first line of nirvana's post, I thought about it and realized I wrote my first bits of code about 30 years ago too.

You'll have to pry my URL bar out of my cold dead hands.

If you don't mind, would you explain that a bit more?

Interesting to note, but not really all that informative. An in depth comparison of libraries might be more useful.

Intentional pun in the blog? "This shit is crazy! Let me show you a log."

I have been working through the book, and I'm just getting into the meat of it. I'm tempted to skip ahead to the JInterface chapter though to noodle around with some erlang powered graphics.