The Instigator
Pro (for)
3 Points
The Contender
Con (against)
0 Points

Teaching Java in Introductory programming courses

Do you like this debate?NoYes+2
Add this debate to Google Add this debate to Delicious Add this debate to FaceBook Add this debate to Digg  
Post Voting Period
The voting period for this debate has ended.
after 2 votes the winner is...
Voting Style: Open Point System: 7 Point
Started: 3/19/2013 Category: Technology
Updated: 4 years ago Status: Post Voting Period
Viewed: 3,293 times Debate No: 31457
Debate Rounds (4)
Comments (8)
Votes (2)




Thanks to LarztheLoser for accepting the debate and I look forward to an enjoyable and educational debate.

Introductory college courses in Computer Science should teach the Java programming language as opposed to Javascript.

Java: Java is a general purpose object oriented programming language details of which are shown in this link [1].
Javascript: Javascript is an interpreted computer programming language originally implemented as part of web browsers more details of which are provided in the link[2].

Burden Of Proof
BOP is shared. Con must argue that JavaScript should be taught in introductory college courses as opposed to Java, not just that both are equally good.

Introductory college courses are generally those taught in the first semester or quarter of an undergraduate course and sometimes spilling into the second semester or quarter. Ideally, students will learn many different programming languages and most students learn more programming languages through their college years. However, most colleges introduce students to programming by teaching one language in an Intro to Computer Science course after which students will likely learn others. In this debate, I argue that Java must be used to introduce students to computer programming.

1) All arguments must be made in the debate.
2) No semantics. In case of conflict on undefined terms, the most general and relevant definition of the word should be considered.
3) Round 1 is for acceptance only. Any clarifications about rules or topic must be made in the comments section prior to acceptance.
5) No new arguments from either side in round 4. No new sources from Con in round 4.

I will number sources sequential from the start of the debate. This allows citing a reference without also referencing the round number.



I thank my opponent for opening this challenge.

Clarifications (yes, I did go over these in the comments first)

As usual, I maintain that a shared burden of proof is impossible. I'll take it that my opponent means that while he has the burden of proof, I have to make a constructive argument. This prevents me from forcing the onus on to pro, which I had no intention of doing anyway. In other words, I cannot just win by saying that both are equally good.

Javascript can in theory be compiled just like Java, but I'm guessing that's not important to the debate. If I need to justify it then I can do so in my contentions. As should be obvious, my opponent also has sources 1 and 2 in the wrong order. He apologized for that mix-up in the comments.

Like my opponent I will also number my sources sequentially in the debate, not in each round. I hope that this avoids confusion. All of my opponent's other rules, definitions etc look great to me!

Therefore I accept this challenge and wish my opponent very good luck for the debate!
Debate Round No. 1


The resolution asks what should be done by the Universities. To determine this, I will define the goals of introductory classes as the following:
a) To prepare students for a career and advanced courses in computer science.
b) To maximize retention rate for computer science majors.
I will show how the unique features of Java help universities achieve their goals better than Javascript does.

C1) Java Runtime Environment (JRE)

The JRE consists of two things; the Java Virtual Machine (JVM), and the Java class library.

The JVM is unique to Java and provides features such as automated exception handling [1] where the operating system generates exceptions as opposed to crashing [2]. This encourages novice programmers to understand the sources of their errors as opposed to being discouraged by them. Throwing exceptions on Java for simple programs is straightforward and requires only a single class which can extend the RuntimeException class and inherit its properties after which the newly declared class can be used in other classes and programs and made to throw exceptions of the programmer's choice.

Another function of the JVM is to verify the bytecode before it executes which protects the host machine from being crashed by user programs while also controlling access to data that the programmer can declare private [1].

The Java class library is much more extensive than Javascript libraries which allows students to focus on writing original code while using the libraries for code that has already been written before. Javascript libraries on the other hand are more complicated to use, and less exhaustive. They all need to be linked in the original HTML file which reduces Javascript's capability as a standalone program.

C2) Javascript is limited to webpages

Introductory programming languages must offer a wide range of functionality on which students can build upon and learn more specific languages designed for narrowly defined tasks. This allows students to appreciate the full extent of the power of programming right from the beginning of their college years. Besides, if they end up learning only one language, one that is applicable to a greater range of situations is more useful.

Java can stand alone while Javascript needs to be placed inside an html document to function. Javascript is wholly reliant on the browser to understand it. It wasn't developed as a general purpose programming language but rather to manipulate web pages. This makes it very limited in function. It cannot access desktop applications or the file system of the machine it runs on. It cannot open or save local files. These limitations makes Javascipt inappropriate for introducing students to programming.

C3) No barrier to Entry

Before a student can learn Javascript, they require knowledge of HTML (Hypertext Markup Language). Even the simplest Javascript program requires the programmer to insert script tags into an HTML document. In order for this to occur, students are required to create HTML pages which requires the capability to understand HTML and implement it before the first Javascript file is created. Introductory courses must teach HTML in the first few weeks of the course before moving onto Javascript. This lessens the time remaining to teach the students Javascript. Leaving Javascript for advanced courses lessens this difficulty as students in advanced courses are more apt to learn HTML on their own and use the features of programming languages they have already learned (like Java). The alternative to teaching HTML in the first few weeks is to require HTML knowledge as a pre-requisite. This blocks out students who are unwilling or unable to learn HTML on their own or waste a semester or quarter of financial aid taking a course in HTML.

C4) Intimacy

Consider the knowledge of the program gained from writing the simplest traditional “Hello World” program in Javascript and in Java. Javascript requires the programmer to create an HTML file, insert a script tag and type the following in a new file:

alert (“Hello World!”);

This teaches nothing about Javascript except that the programmer is invoking a built-in function. On the other hand, consider how much writing a basic Java program teaches the student about Java:

public class main {
public static void main (String [] args) {
System.out.println(“Hello World”); }

The student learns that Java is an object oriented programming (OOP) language where all code is written inside a class and inside a method. Encapsulation is introduced with the access modifier “public” which is a core concept of OOP [3]. Public classes and methods are available to the client to use whereas in many applications, Java programmers want to practice information hiding. The term “void” teaches students about return types and students soon learn about methods that do have a return type and can correlate the return type of those methods to appreciate the difference between them and the method that they have been used to writing.

As we can see, Java immerses students into the language right from the moment they touch the keyboard by teaching them about access modifiers and return types. Compare with Javascript where the underlying structure of the language is not exposed to students until later on in the course. This intimate connection with the language structure increases interest in the language which keeps students engaged. The benefits of teaching a general purpose programming language like Java outweigh.

I could keep comparing features but I will stop here to see what Con comes up with so we can get to the areas of real clash.



I thank my opponent for opening their contentions.


Javascript is not a scripting language

I didn't think I'd have to prove this to a computer science major, but I guess Javascript biases run deep.

Javascript is the biggest misnomer in computer science - it is a programming language often used as a scripting language. Like my opponent asserts, Java is first compiled to bytecode and then that bytecode is interpreted in some runtime environment (sometimes JRE, sometimes the processor natively understands it, etc). Most modern Javascript compilers however, do not interpret the code as would make it a scripting language, but rather compiles it using the JIT compilation process. This is true for instance of Chakra [1], Tamarin [2], IonMonkey [3] or V8 [4]. Precompiled binaries for most JIT Javascript compilers independant of web browsers are readily available on the net.

Programming languages work by linking in to application programming interfaces (APIs) provided by some kind of host. In Java, this is the Java API. By contrast, languages like C++, C or Javascript are specifically designed to interface with any API. It so happens that the most common API for Javascript is the DOM (Document Object Model) specification, and that this is primarily used on websites. However, there is no specific reason why this need be the case. Javascript is NOT limited to webpages and doesn't require any knowlege of HTML to program even the most complex program. Like Java it can run inside a runtime (for example Adobe AIR), and it can also run compiled (see the JIT compilers above), as well as interpreted (analogous to how C++ can be interpreted as AngelScript). Any program - be it a complex application or a simple script to display "Hello World" on a website - can be written as Javascript. Proof: almost all of WebOS was written as Javascript using Spidermonkey's JIT compilation.

That's why the Javascript Wikipedia entry has more than a screen full of examples of programs using Javascript outside of web pages [5]. It's far from an exhaustive list. Moreover, the popularity of Javascript outside of the web is increasing. Assembly code generated by V8 or other engines could definitely be exported, it just isn't practical compared to JIT because of the huge number of processor-specific optimisations the engines use, and because the compiling process is almost instant anyway. Nevertheless on a specific university system, where the hardware is known, V8 or SpiderMonkey could be quite easily adapted to create standalone programs with no HTML dependencies with just a few minor code changes (ie adapting the linker to use OpenGL/GLUT calls for presentation instead of DOM). Visual Studio already compiles Javascript to Windows programs via the WinJS library [6], although it does make use of HTML5 extensions for some features.

Javascript is much, much easier to debug

Most of the Javascript engines I cited use inline code profiling in order to improve performance. This is like compiling a program in debug mode and having it run faster as a result, which is only technically possible with JIT compilation. The result is that exceptions can be thrown in Javascript with ZERO classes, Javascript always generates automated exceptions as opposed to crashing (unless the compiler itself has an error, but this is true of Java also), and most importantly, Javascript always presents the user with detailed profiling information about what exactly their code did prior to going wrong. This allows a coder to find the cause of their error much more quickly, and they don't need to recompile their sources twice in order to test their solution.

Javascript has extensive libraries

This depends, of course, on what you're trying to do. The Javascript default library has classes for managing almost every concievable type of variable, from arrays to strings to dates. This is usually directly extended by other libraries, like DOM or Node.js. Other libraries are then again built on top of that, like JQuery. JSter, a site that catalogs the "most useful" Javascript libraries, has a directory of 1055 as of the time of writing [7]. By contrast, the most exhaustive list I found for Java was on Wikipedia, which lists 85 libraries [8].

However, it is usually helpful for beginning students to understand the core fundamental concepts that go on "under the bonnet" as they write their first code as well. Javascript doesn't lock you in to using libraries for anything, and if a programmer wanted to they could technically prototype the entire standard library and write their own replacement.

My Case

Easier to learn, harder to master

Javascript makes it super-simple to create a program. Given that you don't need HTML to make the alert function work, unlike my opponent's claim (it could, for example, be linked to a Win32 MessageBox interface call at the linking stage), this is even true by my opponent's admission. It's more logical too - why should you need a class for a single instruction? Classes exist primarily to contain sets of data.

Javascript is, however, more OOP than Java. That's because every function is also a class, and every variable can be expressed as a function. This allows complicated OOP concepts to be explored later in their purest form - as user-defined objects. Java is far more limited in this scope. It is impossible to redefine the Java language from within Java, unlike Javascript (which allows it through prototyping), Java has basic support for objects but no closures, a crucial concept in OOP, and so on. Some of these might be somewhat advanced things that beginner programmers will not need to learn. To be honest, there are also weaknesses common to both languages - operator overloading being the big one. But in terms of the number of language features that this course, or later ones, could introduce programmers to, Javascript clearly wins out. The Javascript implementation is also closer to the C family of languages which

Javascript is more useful

While the Java runtime environment is very widespread, it simply cannot compete with the internet. Since Javascript is the de facto standard for web scripting, Javascript compilers exist for almost every platform in common use. Given the trend towards more cloud-based systems and the trend for Javascript being increasingly used for more than just web scripting, teaching Javascript is a great springboard to prepare students for the future. Meanwhile, support for Java platforms is diminishing, with iPhone no longer supporting it and even Oracle themselves recommending disabling it a month ago due to serious security flaws.

Being an open language, developed on top of an open language (ECMAscript), you can be assured that Javascript will stick around forever. However, if Oracle collapses tomorrow, then with it goes Java, since Java is absolutely useless without their proprietary JRE. Oracle has literally monopolised their own language, rather like Microsoft did with .net (anybody remember how introductory computer science courses used to teach that?), and basically thereby pinned the success of the language on both their own success and own resolve to maintain it.

I cannot honestly think of a single real-world application to which Java is the best suited language. It has all the security problems of a proprietary shell (which makes it worse than .net) and all the speed problems of being semi-interpreted. Even where it is integrated as a chip, such as in cellphones, the only real advantage over native calls is consistency of the API - something that used to be a big concern before smartphones became the norm. Javascript, by contrast, is the world's fastest and most supported language that's suitable anywhere where JIT compilation is suitable, and that's not going to be changing any time soon.


Debate Round No. 2


I am really busy with midterms and a project due this Friday (in Java interestingly enough) so I can't post my rebuttals. Sorry about the inconvenience. My opponent is free to post more arguments if he wants (I won't deny him the extra character space). Either way, I'll post my final rebuttals in my next turn and my opponent can counter in his final round.


I wish my opponent good luck for his midterms.

In the interests of having a fair debate, I won't advance any original arguments or rebuttals in this round. I will, however, take the opportunity to tidy up two quick things.

First, the cut off sentence reading "The Javascript implementation is also closer to the C family of languages which" in my last round should in fact read "The Javascript implementation is also closer to the C family of languages which makes transitioning to those languages later in the course easier for students". I have no idea why that sentence was cut off.

Second, I should probably define JIT compilation in case anyone doesn't know what it is (it is a bit obscure). JIT stands for just in time - it means the program compiles itself while you run it. In this way code is only compiled as its needed to run the program. Apologies to not-technically-minded people who may be reading this debate, it's easy to get carried away in programming-speak in debates like this.

I look forward to reading and responding to my opponent's final contentions.
Debate Round No. 3


1) Java is more useful and easier to master

Con compares the Java Runtime Environment My opponent mentions the cross platform benefits of Javascript. However, Java was designed by Sun to work on multiple platforms making it possible to develop Java applications over the internet [4]. Oracle has also released to security updates to fix flaws [5]. The flaw my opponent is referring to has long since been fixed. It is like saying that Windows 7 should not be learned by children because Windows Vista was flawed. The only difference in my analogy was that Oracle didn't rename the fixed version of Java. Oracle also changed the default security setting for Java from "medium to "high" alleviating concerns over security issues [5].

Con says that if Oracle collapses tomorrow, Java will go with it. This is an unsupported assumption. There is no reason to believe that Con's scenario will hold true as opposed to Oracle selling the JRE to another business or making the JRE open source before going under. In any case, Oracle's value has been increasing over the last 1 year, 5 years, and 10 years consistently [6] so this is a far fetched scenario. Java is also about 200 times faster than Javascript [7].

My opponent also metions some Javascript features which are very advanced. This is non-topical to the resolution as we are talking about an introductory course. While he claims that Javascript is easier to learn and harder to master, he provides no reason why this is supposedly a good thing. While Java may have a steeper learning curve in the first couple of weeks, by the end of a course, Java students feel a sense of fulfillment from having mastered the language as opposed to Javascript students who have done the easy stuff but there is much more complex stuff that they don't understand.

2) Downfalls of Javascript

My opponent says that Javascript is not a scripting language. I never called it a scripting language although wikipedia does. Let's examine this definition of Javascript from wikipedia.

"Javascript is a prototype based scripting language that is dynamic, weakly typed and has first class functions."[10]

Every adjective to Javascript provided shows why it is a terrible choice to teach in introductory classes. It is dynamically typed, meaning it executes at runtime what many other programming language would perform at compile time. These behaviors include extension of the program by adding new code, by extending objects and definitions, and by modifying the type system among other things [9]. Doing this at runtime makes it more difficult to find errors.

Statically typed languages allow the programmer to catch the majority of their errors at complile-time by reading the compiler messages and correct their code before runtime. Correct faulty code at runtime makes little sense because the programmer doesn't know whether there is an error before running the program which gives programmers a false sense of security. Runtime errors in dynamically typed languages are more difficult to locate because many test cases need to be tested before the program is guaranteed to be running fine whereas with compile time errors, the compiler does the job for the programmer.

Javascript is weakly typed. This has many disadvantages. Weakly typed languages catch fewer errors at compile time and some might even remain after testing has been completed [12]. While it is possible for a weakly typed language to be type-safe, it is much more rarer than in strongly typed static languages because there is no implicit conversion between types. While this may sometimes be onerous for programmers in Java, doing so discourages lazy habits and ensures that what you declared as an int in the beginning of the program doesn't suddenly end up as a string at runtime while you are completely oblivious to the fact.

Javascript has first class functions. This means that Javascript supports passing functions as arguments to other functions. This creates many implementation difficulties whjch are collectively known as funarg problems [11]. Java works around this by requiring that the context used by context used by nested functions in anonymous inner classes be declared final.

3) Unique features of Java

Standard library:
Con claims that Javascript has a large number of libraries. Most of these are non-standard and require additional time and effort to learn. A course on Javascript can hardly spend hours teaching jQuery and other libraries that add a layer of complexity onto Javascript. Java's standard library has hundreds of classes and multiple methods within each class as shown in this page from Oracle [13]. Every method also lists the parameters it takes so it is a simple matter of plugging in the required parameters to get the required result.

Dynamic Binding and Polymorphism:
Polymorphism in Javascript doesn't work the same way as it does in Java. In Javascript, if you have two functions with the same name, the most recently defined function will always get called and there is no choice offered unless the programmer makes specialized functions just to support multiple possibilities [8]. In Java, the method that gets called depends on the number of parameters being passed so the programmer can choose to invoke a specific method by passing in the right parameters. Furthermore, suppose you want a subclass to have a method with the same name as a method in its superclass, but behave differently from the method in the superclass, you can override the method in the superclass with the method in the subclass. So, when an instance of the superclass calls the method, the superclass's method is called and when an instance of the subclass calls the method, the subclass's method is called. The meaning of the method depends on the type of object that invokes it. Note to readers: A "function" in Javascript and a "method" in Java are the same thing.

Classes and Objects:
Con says that classes are needed to contain sets of data and asks why you need a class for a single insturction. The answer lies in the fundamentals of Object Oriented Programming. True OOP uses procedural abstraction. Creating a class and keeping its implementation mostly private creates a requirement for code outside the class to be able to function without knowing the inner details of the class and how the class provides the results that it does. The code outside the class must only know what to provide to the class and what the class gives back. If code outside the class requires any knowledge of the inner workings of the class to work, then the class is no longer a separate module and its implementation cannot be edited or changed without also affecting programs that rely on that class. Hence, Java is organized in a way where everything is contained within classes. Non-OOP programming languages lack this feature making them inferior to Java. While Javascript is an object oriented language as well, I have shown in my previous round how you can write Javascript code outside of a class in what would in Java be a violation of an Abstract Data type wall.



I thank my opponent for continuing his case, which consists mostly of completely new attacks on Javascript, dropping much of round two's material. I challenged him to tell me ONE single example of where Java is the most suited language. He could not. Instead he claimed Java was...


My opponent's source does not say Java can be developed over the internet. It cannot - in fact, his source specifically warns not to confuse the Java mantra with "write anywhere". Java requires a special plugin to be used in all web browsers, while Javascript is available by default. Moreover, Java can only be developed on platforms supporting Oracle's "Java Development Environment", of which there are around a dozen, all exclusively available from Oracle's website.


Worth noting that Javascript has NEVER had to fix any security flaws in the language. Java has had several exploits in the past.

Supported by more than just Oracle

Even IF this was to happen and Oracle was just kind enough to let Java go (not likely) it would end up like Free Pascal instead of Pascal. Face it, nobody uses either Pascal language nowadays, because why would you when you have languages like c++ and javascript which have NOT collapsed? At the very least Apple allowed others to develop their own Pascal compilers, unlike Oracle.


The test my opponent used for the speed of Java comes from a dubious forum post from over 2 years ago. Javascript speeds can change drastically in a week [3]. I also had my doubts in that the author tried to use Java code ported to Javascript to prove Java is faster, when native code would have run much faster.

So I did my own testing. The program is simple - compute PI to 2000 decimal places. The Javascript test using the Machin Formula is freely available on the net [1]. Using V8 on my machine I get a time of 0.146secs. I then rewrote the code for Java [2] based on native code [4]. On my machine it executes in 0.17secs. So Java today is around 16% slower than Javascript. If you add in the additional time it took to compile the Java program, Java is about 100% slower than Javascript on my machine. And that's not to mention the extra time it took to run both programs from the command line (Java) versus clicking one simple button (Javascript).

I should add that I can easily see several ways the Javascript code could be made even faster. The code was clearly designed to be understandable, not to be as fast as possible. In any event, Java is conclusively NOT 200 times faster any more.

Lacking in advanced features

Having beginner students not feel that they've learnt everything is good because they know what they still have to learn. My opponent agrees the initial learning curve is steeper.

Not dynamically typed

This makes it easier to debug if there is a profiler available that can tell students about what their variables are up to, and tells them which variables were responsible for the error. It makes debugging faster as it ignores the compile step, and the program does not need to be compiled by Java with a profiler, which is good because Java's profiler is INCREDIBLY slow. Getting students into the habit of using a profiler early also helps them track memory leaks as they become more advanced. The "false sense of security" argument only works if there was something to give that security in the first place - since there is no compile step, no security is given. Mind you, a Javascript programmer need not search far for errors, as Javascript's automatic error reporting will always catch them. No logical test cases need to be done since most Javascript profilers do this automatically (ie V8, SpiderMonkey), basically telling the programmer exactly how to fix their code as well.

Not weakly typed

This only leads to errors if programmers are not careful with typing. Incidentally, the SAME ERRORS OCCUR with strongly typed languages like Java. Javascript simply makes it easier to convert types by building in weak typing as a language feature.

No first class functions

Funarg problems only occur in languages without closures. See his own source #11 for that. Since Javascript supports closures this is an extremely important OOP concept, and first class functions are necessary. Not only that, they are very useful too - for example, pointers to functions are what allow multithreading to happen, which is way easier in javascript than java.

Has a large standard library

Having a smaller standard library is actually good, because having a big standard library confuses and overwhelms beginners. For students to write their own methods for some of the more complicated things, at least in earlier courses, can be valuable learning in the same way that having kids to their own experiments in high school science classes is valuable learning.

Better Polymorphism

Javascript's polymorphism is different, not better or worse. The "more recently defined" function statement in Javascript can act very differently with different parameters because the arguments array of any given function is always dynamic in javascript, so (this is confusing for those who don't know Javascript) a single function statement can define multiple functions. The meaning of a method can also be changed by the object that invokes it using the special "this" object in Javascript.

No Global Scope

My opponent's whole argument here is that OOP languages have encapsulation. Given that javascript does too, I'm not sure why this proves all code must be contained in a class. While programs themselves can be represented as classes, the explicit declaration thereof in every single program is completely and entirely un-necessary for the compiler to be able to build the code. Proof: Javascript does it.

Why Javascript is, in fact, better

In 40 years time, what languages will still be in use? Will it be a closed, proprietary language by a single developer with basically the bare minimum of functionality for OOP, which takes forever to learn (not that there's even that much you can do with it) and isn't really suitable for any application. Or will it be a modern, expressive and evolving language based on advanced principles, but easy to pick up? A language that is free of strange syntactical mannerisms, secure, easy to debug by simply watching what your code does and having any errors highlighted for you as they happen - and allowing you to fix them as they happen without having to start over again? It's about what would the most enriching and useful learning experience be, the most useable for students who perhaps aren't even studying the subject and are doing the introductory paper as some sort of general education requirement.

I think only one language in this debate fits the bill.

The resolution is negated.


9 -
10 -
11 -
12 -'s_formula_(Java)
Debate Round No. 4
8 comments have been posted on this debate. Showing 1 through 8 records.
Posted by larztheloser 4 years ago
I definitely agree that c++ is easier than java. GW-BASIC is very dated though.
Posted by makhdoom5 4 years ago
oh man who teach java in introductory cources.
its so tough.
i think they should do GW basic.
than visual basic.
or C
than C++
than JAVA
Posted by larztheloser 4 years ago
... I forgot to update my inline sources to this other numbering system. Oh, well.
Posted by F-16_Fighting_Falcon 4 years ago
I accidentally numbered my sources starting from [1] in round 2. Oh, well. I'll just have to make the numbers clearer for future reference.
Posted by F-16_Fighting_Falcon 4 years ago
Okay, makes sense. Looking forward to it.
Posted by larztheloser 4 years ago
"you can't win by saying both are equally good and both should be taught."

That's what "I have to make a constructive argument" means. I'll spell it out even clearer, since we're both on the same page. (:
Posted by F-16_Fighting_Falcon 4 years ago
Regarding sources, yes my apologies for the mixup. Javascript can be compiled as well; I was just using the wikipedia definition as an introduction and it is not very important but feel free to make that clarification.

The only issue I have is with the burden of proof. I feel that if one person takes on the BOP and both argue equally well, the Con automatically wins. However, I wanted it to be such that if we both argue equally well, then it should be a tie by default; and if one of us argues better than the other, that person wins.

I know we are probably not going to agree on whether a shared burden of proof is possible so I'd say go ahead and make the clarification. I wanted my intent to be clear i.e. you can't win by saying both are equally good and both should be taught. I've seen a lot of debaters use that strategy although I don't think you had that in mind. My point about BOP was made under that context. If you are arguing that Javascript *should* be taught at the expense of Java in effect defending almost a mirror image of my position, then I don't thing we will have a problem.
Posted by larztheloser 4 years ago
Hey, Can I make the following two clarifications:

"As usual, I maintain that a shared burden of proof is impossible. I'll take it that my opponent means that while he has the burden of proof, I have to make a constructive argument. This prevents me from forcing the onus on to pro, which I had no intention of doing anyway.

Javascript can in theory be compiled just like Java, but I'm guessing that's not important to the debate. If I need to justify it then I can do so in my contentions. As should be obvious, my opponent also has sources 1 and 2 in the wrong order."
2 votes have been placed for this debate. Showing 1 through 2 records.
Vote Placed by drafterman 4 years ago
Agreed with before the debate:--Vote Checkmark0 points
Agreed with after the debate:Vote Checkmark--0 points
Who had better conduct:--Vote Checkmark1 point
Had better spelling and grammar:--Vote Checkmark1 point
Made more convincing arguments:Vote Checkmark--3 points
Used the most reliable sources:--Vote Checkmark2 points
Total points awarded:30 
Reasons for voting decision: I give Error Handling and Library Issues to Pro, and Barrier to Entry to Con. I call the versatility a wash. I think there was some off-topic-ness, as introductory programming classes are designed to teach you programming in general, not lock you down to a specific language. Overall, I think Pro more successfully defended his on that front, but not by much.
Vote Placed by Nimbus328 4 years ago
Agreed with before the debate:--Vote Checkmark0 points
Agreed with after the debate:Vote Checkmark--0 points
Who had better conduct:--Vote Checkmark1 point
Had better spelling and grammar:--Vote Checkmark1 point
Made more convincing arguments:--Vote Checkmark3 points
Used the most reliable sources:--Vote Checkmark2 points
Total points awarded:00 
Reasons for voting decision: Strong arguments for both sides, great debate!