Why is it always uphill both ways to school?
I can’t wait until JMJ 2.0 (my son’s name is Jarrett Marshall James, aka JMJ 2.0) is old enough for me to sit him down and write his first program. To give him an idea of what it was like “back in Daddy’s era”, I will give him some completely crippled language that is missing useful features like eval() (yes, I am hung up on dynamic languages), with libraries that are poorly documented (you know, where the “DoRoutine() method is described as, “Does the routine” without explaining what the routine is…), and having to follow someone else’s spaghetti code to get anywhere.
I hate to say it, but OOP lends itself to spaghetti code far worse than GOSUB/GOTO ever spawned. Especially ones you get to a class that implements a few interfaces, and then for giggles, is a partial class, so you get to then try to figure out if the functionality you are looking for is in the current portion or the rest of the partial class (or what the partial class is inheriting, for that matter!). I am at the point where I think I need to spend a few hours each day reading those “Choose Your Own Adventure” books, just to refresh my skills at jumping around. Reading a modern OOP program is like trying to read one of those from start to finish in order, close your eyes, and figure out the optimal set of choices to make to get the best ending. No lie.
If it weren’t so darned nice when these things finally come together and work right, I’d be ready to hang up my code editor for good.
J.Ja
Don’t forget that it was in the snow too with holes in your shoes
.
But hey, I’m one of those people that actually did have it pretty rough and I grew up somewhere that was the equivalent of the US in the wild-west.
I love it when all the code finally comes together in Perl myself. And the fact that it’s practically self-documenting is a bonus. Here’s a snippet:
@P=split//,".URRUUc8R";@d=split//,"
rekcah xinU / lreP rehtona tsuJ";sub p{
@p{"r$p","u$p"}=(P,P);pipe"r$p","u$p";++$p;($q*=2)+=$f=!fork;map{$P=$P[$f^ord
($p{$_})&6];$p{$_}=/ ^$P/ix?$P:close$_}keys%p}p;p;p;p;p;map{$p{$_}=~/^[P.]/&&
close$_}%p;wait until$?;map{/^r/&&< $_>}%p;$_=$d[$q];sleep rand(2)if/S/;print
I find that this is always a misconception when the reality is, you are always walking into the head wind. You usually lean forward to push your self so you end up walking similar to up hill, but no matter. In reality you are always going against everyone else’s standards, sometimes even your own.
I am going through 7 years of files realizing how much I lack a sense of organization.
I know, we all have different standards. I am sure that what I find sensible, someone else gets confused by. Part of the problem is that I cut my teeth on a mainframe, was taught by mainframe people, and grew up with a father who was a mainframe guy. So I am deeply steeped in the procedural code style, and the OOP stuff is a trainwreck from that perspective.
J.Ja