Learning to program is a bit like learning a foreign language: you can learn the syntax and the grammar, but becoming fluent in expressing your ideas, or even just understanding how other programmers express ideas, takes more time.
There is, however, a difference, and it is a significant hurdle which is often underestimated: I may wish to express my ideas in French but on the whole they are ideas that I already have in my head, and I know how to express them English. When you learn to program you also have to master a collection of new concepts and programming ideas that make sense when used together, and then understand how to manipulated them in order to solve problems. (You can learn how to control a car fairly quickly, but you are not safe alone on a public road behind the wheel until you have developed the habits of thought that allow you to instinctively predict the actions of other drivers and anticipate the consequences of your own actions.) The mental skills required for producing good software are sometimes known as Computational Thinking.
Most experienced programmers find learning new programming languages fairly easy, because the grammars of programming languages are always very, very much simpler than those of natural languages. Such programmers have already mastered the fundamental concepts of computational thinking so learning to express them in a different form is not so hard. It took me years to become an expert programmer in my first language, but I now reach the same level of competence in new languages in a matter of weeks.
If you are learning programming for the first time, you will actually spend most of your time acquiring these concepts and understanding how they can be used to solve problems. (I really appreciated this distinction when I studied for a Computing Masters degree and had to learn PROLOG, LISP, and SQL which required me to acquire new concepts and unfamiliar ways of understanding problems.) it helps if you have some guidance.
You have many advantages learning to program today (compare with my experiences back in 1970). We now know more about how to teach programming. (I had to work it out a good deal by intuition and trial and error.) We know all about computational thinking and what people need to understand. There are many good tutorials out on the Web. There is, however, one big disadvantage: back in the 1970s computing was still a relatively young discipline and we could solve interesting problems - those too difficult to tackle with pencil and paper - with fairly simple programs. (OK, we often had to be ingenious to cope with the limited speed and memory capacity of the computers available back then - but that was usually a fun intellectual challenge.) Today it is frankly harder to write a program that does something useful which has not been done many times before. Interesting stuff now tends to be big and complicated. Furthermore, useful stuff almost always relies on using software libraries that other people have created (for example, to produce smart-phone graphics). You have to learn how to use all these tools with all their own slightly arbitrary rules.
To some extent this is the same with Processing. The core grammar is actually very small: most of the things we want to do, like drawing lines and rectangles, are done with calls to library tools, such as line(x1,y1,x2,y2) and rect(x,y,w,h). A lot of the time you spend learning to use Processing to build interesting images is spent looking at the Reference pages for the library routine that does what you want. At least, however, many of these tools , such as line(x1,y1,x2,y2) and rect(x,y,w,h), are about drawing concepts that already make some sort of sense to us. We can already do quite a lot that is interesting with just a few of these tools. Hence, learning to program with Processing has some big advantages, in that we can fairly quickly do original and interesting things with just a little learning.
Most of the decisions you make while writing a program are either about how you remember information (what and where it is, and how it can be found and used) or they are about algorithm: the recipes for manipulating information.
Novice programmers tend to focus on writing algorithms. Trained professionals know that carefully though-out organisation of information is usually the key to well-constructed software. We need to start with algorithms, but neglecting data organisation is a recipe for impenetrable programs full of mistakes.
There are two crucially important algorithmic concepts: iteration and conditional actions ("if-then-else"). Iteration is about doing something over and over again until we reach some objective. We might, for example, wish to draw a Lissajous Curve as a series of short straight lines. We iterate of each of the short segments, working out just where to draw the line, until we have done the entire curve.
Conditional actions are about doing different things depending on the state of information that the program currently knows. We may, for example, detect whether the "s" key has just been depressed and released and IF that is the case THEN we save the current state of the drawing area to an external file ELSE we do nothing.
Iteration very often makes use of storing information in data arrays, which we can imagine as a series of sequentially numbered boxes (usually called elements). We often work through all the elements of arrays one by one using a for() loop. This is the simplest way of structuring information - but it is just the simplest.
Iteration is very frequency use to get very accurate answers to problems by first making approximate guesses, then seeing how far away we still are from the target, then making a correction before trying again, and again, and again until we get as close as we need to be. (See, for example, my exploration of complex dynamics.)
A great many interesting images can be constructed using just these elements of the Processing language. They can be learned just by following the first tutorials of the Processing web site. One of the real advantages of using Processing for this purpose is that you can see the iteration and the conditional decisions happening on the screen in front of your eyes. Learning to program this way provides both immediate rewards, in terms of visually appealing result, and immediate visual feedback on whether your instruction are actually achieving the effect you wanted to achieve.