The order of subjects in beginner's curriculum This year I'll be an unofficial teacher assistant in the CS class of 9th graders.
Background
This question is about a curriculum for introducing students to programming in java.
The students are in 9th grade (14-15 years old) and are not expected to have any background whatsoever in computer science (usually some do have, but that's not relevant to the curriculum. Differentiating it is something relatively easy at this stage).
This curriculum spans 2 terms (1 year - Sept. to June), and is meant to build a firm foundation for students. The subject is compulsory in 9th grade. I have some doubts regarding the ordering of the subjects in the curriculum.
How it stands
Students are initially introduced to computers in general.
The first lesson is always brainstorming: &quot;What is computer science?&quot;. It's established from there that programming (&quot;computer science is writing code&quot; is usually a response of a few students) is writing something, and then converting it into binary (it's expected that they know that the binary numbering system exists). The students use the remaining time ($\pm$10 minutes) to write the famous:
public static void main(String[] args){ //we don't explain this line
    System.out.println(&quot;Hello, World!&quot;); //sometimes we use a Hebrew alternative:
    System.out.println(&quot;!שלום, עולם&quot;);//which is literally the translation
}

That's the first lesson. From here, I'll list the subjects (each one is a subject, and not a separate lesson; lessons are ignored, I only address the subjects of the curriculum) taught (the language used to teach is Java)
   0. (First Lesson) introduction and simple printing of text

Simple Eclipse console Input\Output and user input (print what the user inputs etc.) as well as variables (just primitives, and just int,double,char and String).

Mathematical operators: +,-,*,/ as well as %. The curriculum has an option to teach increment  as well as +=, -= and the rest.

Conditionals: if, if\else and nested ifs. Also boolean is introduced.

switch-case. Not much to say about this at this level.

Math library. This is one of the things that caused me to doubt the order of things in the curriculum.

for loops and various uses. Arrays are not taught in the curriculum at all

while loops.

Nested loops.

functions. yes, functions:
static returnType functionName ( parameters)
{
    //operations
    return returnValue;
}



That's it.
Doubts
I spotted a few issues in the curriculum. First and foremost: Where are all the arrays? I want to include arrays, but I'm not sure where\instead of what.
Teaching for after arrays seems better than before, because then I can show the foreach in the same lesson. They are essentially the same (but not 100% equivalent. Concurrent modifications is something beginners aren't ready for). So I am uncertain about the order of the subjects.
Secondly: Functions. Again, why? I want to remove them from the curriculum (students learn about them in the following years anyway, as part of OOP), but this might do more damage than good. Students might want to know, after an entire year, what exactly is the meaning of the public static void main from lesson 1.
Functions can explain that, but other than that, it's pointless at this stage (because they'll learn it anyway, should they major in CS).
So, does the order of subjects in the curriculum, as it stands, make sense (keeping in mind that arrays are not covered at all)?
Note: this question is not a duplicate of this one, simply because I already have a curriculum, and I am asking for a review of it. I'm also asking about specific aspects of my curriculum, and not general &quot;hand wave-ish&quot; things.
We teach AP CS assuming that our students come to us with no prior computing background. Being that the language for AP CS A is Java, we plan our sequencing accordingly. We don't follow the approach of starting with Hello, world. and user input because I think it (main, System.out.println, and Scanner) produces too much of a cognitive load at once . I always try to minimize hand waving as much as possible in the early parts of a CS course to help students build their confidence in navigating code. 

While Eclipse is commonly used in industry and higher academia, an introductory course isn't industry or higher academia. So we use an IDE that is more appropriate for the new learner. We utilize BlueJ to begin demystifying Java from the very first day of class. Thanks to BlueJ, we don't have to discuss main or making tester/runner classes to run our code. In our post-AP CS course we can introduce IntelliJ or Eclipse, once the students can comfortably grasp the idea of multiple classes and project directories. 

Our decision to introduce objects early was inspired by Dr. Kolling's book's sequencing and the fact that Java is the language taught in AP CS. Others may chime in by saying they think objects should be introduced late. I disagree for the reasons previously mentioned. Should we leave AP and teach Python or Javascript, I would wait until later in the course to introduce OOP. That being said, here is our general outline:


Introduction to OOP


What is a class and what is an object?

Writing Java Classes


What makes up a Java class?
Fields
Constructors 
Methods


Conditionals
Logical Operators
Java Math and the Math Class




At this point it's September and my students can navigate an entire Java class and the hand waving of public static void main(String[] args) is gone. That's hugely important and beneficial. 


Classes as Data Types for Other Classes


Encapsulation

Strings
1D Arrays


Looping

2D Arrays
The ArrayList Class
Inheritance, Abstract Classes, and Interfaces
Algorithms


Recursion
Searching
Sorting



Keep the students in mind. Remember where they are coming from and that your goal isn't to turn them into CS researchers or software engineers in a single year. Expose them to the content in an order that appropriately challenges them, while avoiding the statement "You can ignore that for now" as much as possible.