Are Some Programming Languages More Aspie than Others?

Post Reply New Topic

I've been thinking about how not even the information technology (IT) industry is immune from the fads that permeate the rest of NTness, so I've begun to wonder if some programming languages simply have it while others persist mostly as the result of hype. My theory is that two factors affect how aspie vs. how NT a given programming language is: technical and socio-cultural. It is quite possible that more aspie programming languages are preferred by aspies whereas more NT programming languages are popular with NTs.

Technical conditions likely make a given programming language more "aspie." I would say these programming languages emphasize characteristics we ourselves are known for: attention to detail, preference for the concrete over the abstract or metaphorical, and an inability to see the forest through the trees. The quintessential example is the various assembly languages; to use them effectively, a programmer must memorize scores of opcodes and processor registers; even displaying a line of text to the console requires lengthy code.

Technical considerations can also push a programming language towards the NT. Such programming languages would present functionality in layers of abstraction such as an object-oriented hierarchy of classes and series of polymorphic interfaces. A supplied library of Collection classes hides the lower-level details of how, for example, a binary search tree is implemented for efficiency. The user typically calls a series of methods and may be unaware of how many methods those methods call (contrast this with assembly). Java and C# embody this ethos well.

Socio-cultural conditions work on top of the technical considerations and may make a technically NT language very much aspie and vice versa. For example, Python is a high-level scripting language, but thanks to its deep association with free software and the Linux/hacking community (a very aspie group), it has significant aspie "street credit." On the other hand, a fussy, detail-oriented programming language like RPG may be more NT because they're still in use due to very NT business decision making.

*shrugs* I'm an aspie, but I couldn't hack/use Linux, though more the former, to save my life. :\

Could you make this post a bit better organized in terms of listing aspie like languages vs. NT styled ones?
Like making a list of ones that you think are one or the other, or better indicate which ones and their characteristics make them aspie/NT oriented? :\

I don't know anything about programing languages but think this thread raises a very interesting question.

My interest is that "natural" language is increasingly understood to be like an organism which has evolved in direct response to its "host", the human brain, which means that language today is adapted to average/normal brains, and not to minority ones. Therefore the serious mismatch which exists between AS brains and language esp speech because it seems that use of language requires shutting down so many other functions in order to run it.

Sooo.. what I am wondering is whether certain programming languages might be more NT because they are most like "natural" language in terms of internal "laws"/structure/grammar, whereas the ones which suit AS thought processes ( if there is such a difference ), are the ones least like natural language?

Has any study been done to measure degree of difference or similarity between the internal laws/structure/grammar of various programming languages and "natural" language?

It's an interesting line of thought. I'd like to see a list of languages and how you classify them and why.

A few counterpoints:
1. AL was created as the first way to interact with a computer above machine language. This had nothing to do with aspie or NT. At the time AL was created, there was not speed or memory enough to use higher level languages. That's was the whole point of AL, to write the smallest and fastest programs as possible because computers were so slow and expensive, and access was limited in terms of both time at a terminal and time allowed in the CPU for your program to run.

2. In my opinion, the main point of things like the STL is not to hide low-level details, the point is to re-use code and not re-invent the wheel for every single program you write. Without the STL, a good programmer would write their own binary tree (your example) and then reuse their same tree implementation everytime they needed it. This is the same concept as using the STL, except that now everyone uses the same binary tree instead of 100,000 programmers each writing their own implementation that does the exact same thing, thus re-inventing the wheel that many times.

But, there is merit to some of the things you are saying.

I think you are likely to see that Aspies have strong preferences for various programming languages,
but it is less an Aspy thing, and more of a what sorts of things do you have to do in your job.

I do think that you are likely to see Aspies have a stronger demand for a fixed style in their code
as consistency and clarity in code appearance lead toward less brain load when interpreting code.

A couple of style rules I try to follow for c style languages include

each control structure has a brace body.
every if has an else

ThisIsADataType
this_is_a_function
thisIsAVariable, so that the capitalization rules speak to me as to what it really is....

Everyone is different, and use whatever techniques are needed to cope with their environment.

I actually have a degree in (mainframe) computer programming; but all it taught me was that I'd never make a good programmer...

I actually found assembler to be easier that people let on, though we didn't go very far with it.

Cobol (Completely Obnoxious and Boring Obsolete Language..') had me in fits. Of course, it was Cobol '74, so hopefully they've cleaned it up some since then. The programming language is as old as I am (written/birthed in '57..

RPG was either a Soviet weapon or a programming language...or both.. Imagine a language formed by filling out forms. I did find out that putting a check box in the wrong column would cause 1 line per page instead of 60...

C I tried, but got lost about the time they wanted us to do math only using 'ands' and 'ors'.

Basic wasn't too bad, I could follow that in my head. Never went very far with that, either.

I did get fairly good with Lotus 123 macros, but that's as close to programming as I've done in almost 20 years. Did take a Linux course; it was like batch files, only sideways...

To be honest, nowadays I'd just as soon take a tool and create things. I'm working on learning Flash, which is about as programming as I get nowadays.

Other people may have different ideas.

PERL without a doubt.

ruveyn

I don't think you have an argument. Today, most people choose the programming language they use based on the extra functionality provided by standard libaries or the community. For example, PERL was extremely popular when it came out due to its regular expression support. Due to this popularity, other programmers built libraries for their languages of choice to do the same thing. So PERL loses its advantage. Since I hate the variable syntax of PERL, I'd never choose to use PERL if the feature I need is available elsewhere.

As for the business side of things, my experience has been that the language does not really come into play. Business decisions usually follow using the norm to develop new things, so I could see a business deciding to stay with the language they know rather than a new one. But really, I think most companies just want to produce software that works efficiently and that users will buy. Most users don't care about the underlying code unless it's broken or slow.

I am not certain it's just me, or my Aspie, but people how see my C or even C++ say it still looks to much like Pascal with strict blocks and avoidance of anything which can't be shown in the form a Nasi-Schneiderman-Diagram (so you will not found in any of my source code a break or continue statement in loop or even an return/exit in the middle of method/function, the use of exceptions is extremely localized).

I admire different languages for different reasons.

Ruby is really elegant, highly abstracted language much closer to natural language.

I’m really liking Lua. It is really simple and lightweight/small embeddable language that does what it says on the tin. A great way to allow your users to extend your application without a huge thumbprint, and it is also good in its own right.

I have heard good things about Python too.

Personally I think C++ is a mess, I’m not sure why it has such loyalty.

I have done some assembly/low level programming, it is not a problem but you just can't rely on it for every

No so for me. You will find in my code very frequently stuff like this:

It is a mess, because it mixes up to many different concepts:

On the bottom line you still have the low level functionalities of C, than you have on the top different Class-concepts with different methods of building up class-hierarchies (public, friend, as a member, etc.) and this mixed up with the concept of templates.

It just gives the programmer to many way of doing things and provides to many ways of "muddling trough", even when the basic concept is a mess in the first place.

Sorry... but I had to comment...

I hate it when someone codes a perfectly good syntactic boolean, which is the correct thing to put in the condition, and then adds a layer to it, by making a comparison it to the boolean constant, in order to see whether it is what it says it is or not?

I also find the above structure very dubious, as the function gives no indication (on the face of it) of how many of the three things it attempted to do were actually completed.

At least you don't suffer from the malaise of insisting on putting parentheses around the expression that follows "return".

Functionally identical:

It just makes it clearer for what is the check-up. I found the definition of the boolean-value in C++ always a little bit obscure, as there is a possible convertion from int to bool - something I think is more strange from the concept behind (Pascal is here much more restricted). The following code would not compile in Pascal:



In C or C++ it will compile perfectly! Also no one can save you from redefinition of the "true" or "false" and threfore I play here on the safe site and express directly for what I am checking.




In my style each one of the methods function will raise there own error message, so the ErrorHandle will rite a log-file like:



So the error log simulates something like a stack trace.



Most likely, but I didn't found anything in the standard, that "DoSomethingOther" will be really (!) executed after "DoSomething", so my pedestrian way do tell the compiler certainly the sequence.

---

But: As I wrote, my C and C++ still looks a lot like Pascal, which I think is still a superior programming language, if you ignore the extensions by Borland and others.

I'm the opposite. I realize C/C++ and other languages allow you to do this, but I prefer to write exactly what I mean - rather than leave out defaults that the compiler understands. That way if the business hires a college intern, I don't have to count on their knowledge of the language defaults.

Your code, for example, won't do the same thing in VB as it does in C. VB does not short circuit boolean expressions, so each function gets executed. I think the first example is easier to read and cheaper to maintain in addition to being more efficient if copied directly to other languages like VB. I would make a couple changes, however - I would nest the if statements and reverse the comparisons to read:



I reverse the comparisons so that a mistype of a single "=" generates a compiler error. The newer compilers might optimize the if statements for you, but again, I don't feel like you should rely on the compiler to generate what you mean. You should write what you mean.

I always make it a point to learn a language before I use it:
http://en.wikipedia.org/wiki/Sequence_point

I will also exploit every aspect of a language, if it is of any use. In C#, I miss macros (which in C/C++ means that the irritating habit of separating your function's argument list from the function name means that you have to edit the source, when you decide to switch from a function to a macro) and the triadic ?: operator.


Unfortunately, writing code that "looks like Pascal", in a compiler that is as dysfunctional as C++ doesn't really work.

I certainly prefer Pascal (naturally, as I learnt that before C). I have "Algorithms + Data Structures = Programs" in my hand.

Where you show the way Pascal is strongly typed, I certainly prefer such a language. The worst bugs in the world are caused by the generous way C and C++) will happily "interpret" or "correct" your code for you. I always turn on every error and warning that I can, in the compiler, so it does not "help" me with any gratuitous type coercions.

I also find it sad, how people slavishly adhere to laying out their code as would a beautifier. There is obfuscation by removing all white space, but at least you can still see the code. I feel that obfuscation by introducing excessive white space is even worse. When a simple piece of code, that deserves half a dozen lines, instead takes up a whole page, and thereby becomes impossible to grasp as a whole.