Ada

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

static typing.

algol syntax

Ada.

>>2
that's not a bad thing

>>5
Static typing hogs a lot of brain resources. Syntax is complex (syntax of typed languages tends to be more complicated than that of untyped languages), and together with static typing it forces me to spend more resources on dealing with language than with dealing with the problem.

1. Dynamic languages are well-known for their “reload on the fly” productivity. Code can be changed without restarting a process, leading to a faster feedback loop for developers.
2. Dynamic languages often have better designed libraries. Haskell in particular is known for it’s ugly APIs. Very often, the problem is just that an API lacks higher levels of abstraction. Perhaps there is a larger reason why dynamic languages have nice APIs.
3. I’ve read very good, good, bad, and very (very) bad code in both dynamic and static languages. Admittedly, the type checks, IDE tooling, etc. is quibbling, because a good programmer should be able to produce good code in either type of language.

HAHAHAHA
YOU THINK YOURE THOUGH UH ?
I HAVE ONE WORD FOR YOU
THE FORCED INDENTATION OF THE CODE
GET IT ?
I DONT THINK SO
YOU DONT KNOW ABOUT MY OTHER CAR I GUESS ?
ITS A CDR
AND IS PRONOUNCED ``CUDDER''
OK YOU FUQIN ANGERED AN EXPERT PROGRAMMER
THIS IS /prog/
PROGRAMMING IS ALL ABOUT ``ABSTRACT BULLSHITE'' THAT YOU WILL NEVER COMPREHEND
I HAVE READ SICP
IF ITS NOT DONE YOU HAVE TO

>>8
What happened to my /prog/...

>>9
summer this is only a fresh wave of college kids and some school kids... just wait till june 7-9 when all schools let out

then /prog/ will be gone for the summer

>>10
I thought that textboards were hidden well enough. But of course, it's /g/ fault, redirecting their shit to us.

>>11
lol, i'm the guy who redirects them all here. enjoy your /gay/

Can you make some good reasons why I should use Ada instead of C++? or Python?

>>13
C++ and Python suck, Ada sucks slightly less.

>>13
Ada has a feminine name - thats a strong marketing move.

>>15
You are a nigger now.

>>14-15

Could you please provide any rational arguments. I would actually like to know the reasons.

The only applications I've heard use Ada are some military things.

Ada is BDSM on a very high level.
Which is why it's perfectly suited for military applications.

>>17
AFAIK, it's a little more consistent in design than your C/C++. You'll write a lot of "readable" code with a moderate amount of boilerplate. Mil. love these things. Other than a replacement for C/C++, it has not purpose.

>>18
>very high level
Actually, Ada is one the same level as C++. No GC or map-reduce, just plain old structured programming.

>>20
reading comprehension

Oh man.
Ada.

Man.

The reason you can't name anything wrong about Ada is because you're not allowed to

Ada is lowercase COBOL.

>>23
Ada is still used to program certain types of missles used by the U.S. Navy.

>>24
missles

Phonetic spelling is a mark of a lesser intelligence.

>>25


Dictionary trolling is a mark of a lesser ambition.

Horrible implementation of OOP.
Forced separation of space for declaration and initialization of variables.
Bitchy about type conversion

The following is legal in C:

#include <stdio.h>
int main() {
　　int a = 5; float b = a;
　　printf("%f\n", b); return 0;
}

And you won't even get a warning. But in Ada, if you tried this....

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Float_Text_IO; use Ada.Float_Text_IO;

procedure main is
a : float;
b : integer := 5;
begin
　　a := b;
　　put(a); new_line;
end main;

It won't even compile.

>>27
Ada version is so much more readable then C

>>27

I wouldn't want code with errors in it to compile. Those are the most difficult and time consuming errors to find and fix.

>>27
That's because C has The Retarded Coercion of Types.

>>27
Those programs mean different things. I don't think that's a bad thing.

ada > ada lovelace

>>32
Impossible: DARPA never lost its life savings trying to solve Poker.

>>31
meaning is subjective

for a user, only the result of execution has meaning.
for a programmer, only the speed of code writing has meaning.

Ada achieves the same result at slower speed.

>>34
Actually, "the speed of code writing" also has meaning for user, as he'll have to wait till program code is ready and listen to "PS3 HAS NO GAEMS" detractors, who would find such user an easy trolling target.

You know, it's kind of funny seeing people complain about Ada being obsessive about the programmer doing anything in the slightest bit shady. THAT'S THE FUCKING POINT OF THE LANGUAGE. The sad part is that Java has inherited all of this—it just hides it under mountainous cellulite rolls of overloaded functions.

>>36
The point of the language is to impede sales and delay development?

>>37
You didn't know that?

It was intended for safety- and operations-critical systems—major government contractors with billions of dollars to blow; development schedules years long. Like the aerospace companies that build the space shuttle. Ada's about minimizing bugs, despite the learning curve that's required to get used to its verbiage.

Speed of writing wasn't important twenty years ago, when most programmers had been trained on glass TTYs or worse, and naturally thought more slowly and carefully than we do today. It's also almost completely irrelevant when you are going to have to go back and verify the code afterward—a task for which slow, carefully thought-out code is better, anyway.

Ada was never meant to be a language for hackers or hacking, and appropriately they (we?) passed it by.

>>38
BDSM is nice, when you already know what you're doing, have a big design document, that wont change till the end. But to attain that knowledge you still have to explore the unknown and write a prototype in some more flexible language, which requires hackers and hacking.

>>39
You'll get no dispute there from me—but it is what it is: Pascal extended for the purpose of running aircraft control systems. The typical mindset of Ada development involves, yes, having the design worked out first. That's not unusual in the industries where Ada is used. I don't think anyone serious would suggest Ada should be the One True Language—except, unfortunately, James Gosling (trollface here).

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