Ada

Name one flaw about Ada... oh wait you can't

My university is using Ada as an introductory programming language over C++ because they think it's much simpler to understand.

I really don't get how anyone could not understand C or C++.

>>41
It's interesting, that school and university jews hate dynamic languages. Try asking your school teacher, why they have only Pascal, C, Java and Visual Basic, never Lisp, Smalltalk or pure Assembly. Although Assembly and Lisp are simliest languages out there. I, myself, started coding from assembly, because C++ and Basic were too hard.

>>42

They have a class for python and a class for visual basic, but they are not part of the required CS curriculum and can be avoided entirely.

Although they do have a class taught in scheme, which is dynamic.

Also, assembly is compiled, not interpreted.

>>43
Assembly is assembled, which is somewhat simpler. And in most introductory assembly courses, you start off with SPIM, a MIPS simulator.

>>43
Also, assembly is compiled, not interpreted.
Virtual machines, emulators, ...

>>44
C code: file.c -> file.s -> file.o ->file
ASM code: file.s -> file.o -> file

Just one less stage in compilation really...
>>45
Well the same could be said about C then...

>>46
Well the same could be said about C then...
Yes. No language is ``compiled'' or ``interpreted''.

Just one less stage in compilation really...
Assembly instructions map 1-1 to the ``machine code''. Because they are just mnemonics.

>>43
They have a class for python and a class for visual basic,
Basic is statically typed. Python is based on OOP-classes, which are static entities, compared to tagged lists.

Although they do have a class taught in scheme, which is dynamic.
They had in MIT, but replaced it with Java or C/C++ or something.

http://en.wikipedia.org/wiki/Visual_Basic
Typing discipline Static, strong
Dim Count As Integer
Thats it! Even more verbose than Ada.

>>49
What does ``Dim'' stand for?

>>48
Berkeley still uses SICP, IIRC.

>>50
What does ``Dim'' stand for?
doubt it's important.

>>51
Dimension. Classic BASIC doesn't require variable declaration, so it was originally only used for sizing arrays.

>>47
Not Intel x86 assembler. For example, 'mov' corresponds to several different machine instructions based on which arguments are registers and which are addresses held in registers.

Why do I get the feeling that all of the regulars in this channel know nothing about computers outside of their favourite functional fiefdoms?

channel

wat

>>53
You'll figure it out.

Waiting for counter-evidence, btw. I had a much better chat with some people on /g/ who cared about such diverse fantasies as scheduler design.

>>52
For example, 'mov' corresponds to several different machine instructions based on which arguments are registers and which are addresses held in registers.
Yes, I know, but it still is one mov that translates to one of those instructions. Even pusha doesn't magically become push eax | push ebx | push ecx | ....

Why do I get the feeling that all of the regulars in this channel know nothing about computers outside of their favourite functional fiefdoms?
Because you're wrong, and because it's almost summer. But there's no magic inside the computer.

>>52,54
All of those can be represented by 100010ds /r. Saying that they are not the same MOV instruction is like arguing that ADD EAX, 5 and ADD EAX, 10 are not the same ADD instruction.

Now MOV immediate to register, MOV immediate to memory, MOV Sreg and MOV moffs have their own opcodes. MOV CRx and MOV DRx are even handled as seperate instruction in the Intel manuals.

But even with this, x86 assmebly is very WYSIWYG: ``One of the design goals of NASM is that it should be possible, as far as is practical, for the user to look at a single line of NASM code and tell what opcode is generated by it.''
The only exceptions are for labels (optional, if you are insane) and for optimization (optional). So there is an injective 1-to-1 mapping of a line of x86 assembly to x86 machinecode.

But I'm sure you were all very excited on /g/ about compiling BFS.

>>56
injective 1-to-1 mapping
reached retardedness threshold right there

>>47
Assembly instructions map 1-1 to the ``machine code''. Because they are just mnemonics.
Never used a MIPS assembler then?

>>55
Even pusha doesn't magically become push eax | push ebx | push ecx | ....
That's what microcode is for. Anyway, how do you encode a "nop" on x86? There's lots of ways to do it, and they're not all equal.

>>52
Dimension. Classic BASIC doesn't require variable declaration, so it was originally only used for sizing arrays.
Wiki says, BASIC had sigils, like Perl, for the sole purpose of consrving memory (type tags were too costy for toy machines, BASIC ran on).
http://en.wikipedia.org/wiki/Sigil_(computer_programming)

>The use of sigils was popularized by the BASIC programming language. The best known example of a sigil in BASIC is the dollar sign (“$”) appended to the names of all strings. Many BASIC dialects use other sigils to denote integers and floating point numbers, and sometimes other types as well.

So BASIC is clearly a statically typed language.

Why do I get the feeling that all of the regulars in this channel know nothing about computers outside of their favourite functional fiefdoms?
Why should they? Is there anything important outside of Lisp World?

>>42-47,52,55-58
...I think we've exhausted that line of conversation.

Going back to the previous point, it is a little annoying that universities focus on statically-typed languages first, but it's important to understand that a CS curriculum (as outlined in that HtDP paper from earlier this month) is expected to do a great deal of different things. For most students, this means working in industry, and giving them early access to languages that don't enforce strict habits is going to be a recipe for disorderly production code.

Most of these students really belong at community colleges in software design programs, but due to the stigma attached to community college, they end up polluting the goals of your local CS department instead, which is originally supposed to be a theoretical, paper-writing institution that plays with algorithms and complexity all day: math, except with ordered lists of instructions instead of numbers.

This is less of a problem in other departments, although amusingly, engineering schools have recently been experiencing the reverse—they've grown increasingly academified and developed, yes, PhDs! You can now get a degree that says you're Doctor of Philosophy of Engineering. Because, without higher tiers of credentials, how can we possibly be elitist? The same underlying idea is what sends so many bureaucrats' children to university to get a worldly education—driving up tuition and creating the dramatic flare in first-year class sizes.

So, unfortunately, while you and I may hate declaring variables like nothing else, the goals of actual computer scientists aren't the focal points of most CS programs, and that's why they hold off on dynamic languages.

Incidentally, I've heard from younger students in my program that our university now uses Python for CS 101 and its chaser, 121, although students with prior CS experience can skip 101 outright. It took a lot of time to wrestle those courses out of the hands of Java, however, and in general the institution has a fairly obnoxious history of people complaining they weren't trained to work in industry—but we've since tried to accommodate them with a specific software design stream, which is still fairly theoretical. What institution is going to skip out on that much money?

Computer Science is a bullshit degree.

>>59
It's funny to be on the other side of the archaeologist's pick for once.

Yes, BASIC has sigils. VB6 and other newer versions of the language still support and recognize them. Perl sigils, however, are used for vector vs. scalar variables; BASIC used them to implicitly define types, sort of like if Hungarian notation was recognized by C++ compilers. String$, Integer%, Long&, Single!, Double#, Currency@. Booleans were only introduced with VB, so they never got any, at least in Microsoft's versions. (I'm not sure about Byte.) Once the explicit declaration statement was added for variables, most languages no longer required explicit declaration.

Visual Basic supports a datatype called the Variant, which can contain anything. Internally, it's represented as a pointer (with associated type info) that points to the actual data value, but the language presents it to the user as a simple flat variable that can contain anything from the most complex of objects down to a simple classic 16-bit integer, and you can shove anything into it at any time. However, because of the internal pointer structure, it's a little slower. This is one of the reasons to avoid it in important code.

So, the answer is actually that Visual Basic is both statically typed and dynamically typed, while traditional BASIC is only statically typed. If a variable is never given a type in code, it's assumed to be a variant by the parser.

Also, before I forget: yes, there are important things outside of the Lisp world. Mistakes to avoid, magnificent tales and heroic exploits, and actual optimization. It also helps to know and understand what's underneath your favourite house so you can tell what to do if there are problems—or find another house if you don't like it.

CS curricula is mostly defined by textbook publishers anyway.

>>64
Common misunderstanding. The textbook publishers hire professors to write CS books, and they have mostly free reign; it's not like high-school and public school where the material is simple enough for them to stick their fingers in.

Moreover,  it's ultimately your lecturer's decision as to what book he or she teaches with. If you hate your curriculum, blame them first. (or perhaps their immediate superior. or the department head.)

VHDL > Ada

>>65
Not my experience. The publishers enforce the use of the latest and greatest editions just to curb the used textbook market. Some lecturers care enough to make their own material (and some of those later get published), most just use something off-the-shelf.

>>67
Oh, editions, sure. But you can get out of that simply by picking a commodity book that's barely changed in the past thirty years. The C Programming Language is a great example of this in action.

>>68(Seriously, if you're not buying all of your textbooks second-hand, what's wrong with you?)

>>69
niggers stole all the second-hand ones