New to the idea of programming

A

Arved Sandstrom

It will enable them to focus more on programming logic
than on data types and various rules for those.

But it is a double edged sword. They may be up for a pretty
bad experience when they move to a more strict language.

That works both ways - I've encountered a number of programmers who make
a pretty mess of it when they move from "strict"
(statically-typed/strongly-typed) languages to less strict
(dynamically-typed/weakly-typed) languages. These are the coders -and
there is no shortage of them - that if you took their IDEs away, and
forced them to use API docs and a text editor, would have so many type
errors at first compile that it would be obscene. To me that means that
they lacked discipline and were relying on the compiler and their tools
to save them.

My feeling is that if a programmer starts out with something like
Python, and learns programming logic, then moves to Java and has a bad
experience because of strong typing, say, then they didn't really learn
proper programming in Python at all.
6 months is not much for learning programming.

I didn't mean 6 months worth of dabbling in programming on the
occasional evening, I meant 26 weeks worth of 40 hour weeks, or roughly
a thousand hours. If an aspiring programmer can't pick up adequate
coding skills in 2 languages (and by coding skills I mean some decent
ability to translate a problem solution into code) with that amount of
time, then I personally believe they aren't cut out for the field.
If the driver for learning programming is a wish to program
their Android phone, then there are some logic in starting
with Java.

I don't personally think that's the first project a novice programmer
should be taking on, programming smartphone apps. But I guess if you
wanted to tackle all sorts of problems at the same time then you might
as well throw Java into the mix as well.

AHS
 
L

Lew

Arved said:
My feeling is that if a programmer starts out with something like Python, and
learns programming logic, then moves to Java and has a bad experience because
of strong typing, say, then they didn't really learn proper programming in
Python at all.

A programmer should start out with assembler and C, then learn FORTRAN and
COBOL, then Java and/or C#.

The problem with learning Java first is that you never get screwed by wild
pointers.
 
A

Arne Vajhøj

That works both ways - I've encountered a number of programmers who make
a pretty mess of it when they move from "strict"
(statically-typed/strongly-typed) languages to less strict
(dynamically-typed/weakly-typed) languages. These are the coders -and
there is no shortage of them - that if you took their IDEs away, and
forced them to use API docs and a text editor, would have so many type
errors at first compile that it would be obscene. To me that means that
they lacked discipline and were relying on the compiler and their tools
to save them.

There is something that I completely agree with.

I am a strong believer in being able to code in a standard text
editor using command line tools to build with is essential for
being a good developer.

I just don't see any point in doing it every day.

But you could use an IDE for Python as well.
My feeling is that if a programmer starts out with something like
Python, and learns programming logic, then moves to Java and has a bad
experience because of strong typing, say, then they didn't really learn
proper programming in Python at all.

True.

But forgiving languages is somewhat dangerous for those not
learning proper programming. The language may make their code
run. The more strict languages will force them to do at least
some thing right by giving them tons of compiler errors.
I didn't mean 6 months worth of dabbling in programming on the
occasional evening, I meant 26 weeks worth of 40 hour weeks, or roughly
a thousand hours. If an aspiring programmer can't pick up adequate
coding skills in 2 languages (and by coding skills I mean some decent
ability to translate a problem solution into code) with that amount of
time, then I personally believe they aren't cut out for the field.

They should be able to learn something.

And the languages themselves and the most common API's are (usually)
not so difficult to learn.

But I would expect the person to still very much be a novice
in programming.
I don't personally think that's the first project a novice programmer
should be taking on, programming smartphone apps. But I guess if you
wanted to tackle all sorts of problems at the same time then you might
as well throw Java into the mix as well.

I have not done Android work myself.

But some that has claims that it is pretty easy to
get started with.

It could be a good motivation.

Arne
 
A

Arved Sandstrom

A programmer should start out with assembler and C, then learn FORTRAN
and COBOL, then Java and/or C#.

Well, no, they shouldn't. Why don't we just stick to languages that
would be reasonable, in 2010, for a novice to start with?
The problem with learning Java first is that you never get screwed by
wild pointers.

Your sarcasm aside, if a programmer can't manage pointers in C/C++, they
sure as hell can't manage reference type variables in Java either. The
effects will be somewhat different in Java - NPEs and expensive
debugging to pin down business logic errors - but no less damaging.

AHS
 
L

Lew

Arved said:
Well, no, they shouldn't. Why don't we just stick to languages that would be
reasonable, in 2010, for a novice to start with?

Point taken.

Arved said:
Your sarcasm aside, if a programmer can't manage pointers in C/C++, they sure
as hell can't manage reference type variables in Java either. The effects will
be somewhat different in Java - NPEs and expensive debugging to pin down
business logic errors - but no less damaging.

It wasn't total sarcasm. It's more metonymy - "wild pointers" is meant to
include the sort of thing you mention. You are, of course, right, but it's
those sorts of things one wants new programmers to understand.

The problem to which I sarcastically pointed is the lack of architectural
context in programmers' training. For Java it's the JVM, and enough of its
architecture to comprehend Java-style pointers, a.k.a. references, and the
abstract notion of an address. I had an assembler programming course in
college that was worth the semester's tuition by itself. They spent a lot of
time explaining the "indirection bit", a key foundation for me in my use of C
pointers.

Another aspect is to understand the purpose of garbage collection and that one
should not universally rely on having it. Learn the advantages,
disadvantages, and alternatives.

It has value to study some of the wide world of programming - machine
language, compiler writing, data structures, algorithms, Donald Knuth -
concurrently with one's major focus on Python, Java, or any other specific
tactical target.

General competence will come early if you have an aptitude and keep at it. It
needn't take five years, but you shouldn't stop at general competence anyway.
Being somewhat holistic in your studies will accelerate both short-term and
long-term skills.
 
T

Travers Naran

Most people actually learn programming by learning programming
not about what programming is.

Most people give up programming, and the remainder learn programming.
So your claim that they will fail is observable false.

No, it's not.
http://www.siliconrepublic.com/innovation/item/18532-computer-science-courses-ge
http://portal.acm.org/citation.cfm?id=1151604
http://www.computing.co.uk/ctg/news/1827871/it-undergraduates-uk-s-dropout-rate
That is not what young people interested in programming
want to learn.

If they are interested in programming, they can overcome, but a great
many suffer and "stunt". They never learn how to create a program on
their own and have to "copy-and-paste" existing code. They couldn't
tell you why the code works, but they know it works. They are the ones
who struggle most on new platforms and languages.

Although, as a middle-ground, one of the more surprising suggestions I
have heard (but unbacked up by actually trying it in the class room) is
to study existing programs and have NO programming at first. The idea
is that by studying how an existing program works, the learner can
absorb the ideas needed to re-create it.

The reason it stuck with me is that what really helped me learn to
program was looking at other people's code. By seeing how they solved a
problem, usually with commentary on how they solved it, it helped me
grow as a programmer. My favorite books usually include copious amounts
of source code with annotations explaining it.

An interesting choice might be a "Java by Example" book which would
cover two topics at once: learning Java and learning the HOW and WHY of
Java.

That is the kind of book I have focused on for learning Android programming.
 
M

Martin Gregorie

A programmer should start out with assembler and C, then learn FORTRAN
and COBOL, then Java and/or C#.
I started with Algol 60 at university, which gave me a reasonable feeling
for how to structure a program. After that I was thrown into commercial
programming with a macro-assembler (PLAN 3) followed by COBOL. Since then
I've self-taught myself, often on the job, a variety of languages
including Algol 68, Basic, Pascal, PL/1, RPG, one or two 4GLs, C and Java.

I think the OO bit would have been a lot harder without previous
experience in the Algols, Pascal and C. As it was, before meeting Java
I'd developed a pseudo-OO programming style that, in conjunction with top-
down incremental development has been a useful approach to writing in
almost any language.

I'd definitely recommend that an ab initio programmer should start by
learning an object-oriented language and should pick up top-down
incremental development in parallel. I'd be inclined to suggest Java
rather than Python as the first language, but only because the strong
typing allows the compiler to pick up many more mistakes at compile time.
The way Python's untyped dynamic variable assignments manage to generate
run-time errors or unexpected results from mistakes that the Java
compiler would trap can be, I think, unnecessarily confusing for somebody
who is learning to program.
 
A

Arved Sandstrom

Point taken.




It wasn't total sarcasm. It's more metonymy - "wild pointers" is meant
to include the sort of thing you mention. You are, of course, right, but
it's those sorts of things one wants new programmers to understand.

The problem to which I sarcastically pointed is the lack of
architectural context in programmers' training. For Java it's the JVM,
and enough of its architecture to comprehend Java-style pointers, a.k.a.
references, and the abstract notion of an address. I had an assembler
programming course in college that was worth the semester's tuition by
itself. They spent a lot of time explaining the "indirection bit", a key
foundation for me in my use of C pointers.

Another aspect is to understand the purpose of garbage collection and
that one should not universally rely on having it. Learn the advantages,
disadvantages, and alternatives.

It has value to study some of the wide world of programming - machine
language, compiler writing, data structures, algorithms, Donald Knuth -
concurrently with one's major focus on Python, Java, or any other
specific tactical target.

General competence will come early if you have an aptitude and keep at
it. It needn't take five years, but you shouldn't stop at general
competence anyway. Being somewhat holistic in your studies will
accelerate both short-term and long-term skills.
Certainly no argument from me about any of that. And I certainly don't
mean to suggest that just 6 months of FT study, as I've alluded to
elsewhere, is enough time to become a proficient *software developer*,
as opposed to being a one or two language coder. All that you mention
above is part of what a good software developer should have some
knowledge of.

AHS
 
A

Arved Sandstrom

I started with Algol 60 at university, which gave me a reasonable feeling
for how to structure a program. After that I was thrown into commercial
programming with a macro-assembler (PLAN 3) followed by COBOL. Since then
I've self-taught myself, often on the job, a variety of languages
including Algol 68, Basic, Pascal, PL/1, RPG, one or two 4GLs, C and Java.

I think the OO bit would have been a lot harder without previous
experience in the Algols, Pascal and C. As it was, before meeting Java
I'd developed a pseudo-OO programming style that, in conjunction with top-
down incremental development has been a useful approach to writing in
almost any language.

That was my experience also. I had fairly substantial FORTRAN, VAX
assembler, MOS 6502/6510 assembler/machine code (the good ol' Commodore
C64), BASIC (in various flavours), C, and Pascal experience before ever
encountering an OOP language. Oddly enough the order in which I then
learned and used OOP was Prograph, followed by C++, followed by Perl 5,
and then finally Java when it appeared.

In my opinion - and this of course only applies to my experience -
learning procedural programming first helped a great deal when then
faced with OOP.
I'd definitely recommend that an ab initio programmer should start by
learning an object-oriented language and should pick up top-down
incremental development in parallel. I'd be inclined to suggest Java
rather than Python as the first language, but only because the strong
typing allows the compiler to pick up many more mistakes at compile time.
The way Python's untyped dynamic variable assignments manage to generate
run-time errors or unexpected results from mistakes that the Java
compiler would trap can be, I think, unnecessarily confusing for somebody
who is learning to program.

I'm sort of curious as to why you'd say on the one hand that "the OO bit
would have been a lot harder without previous experience in the Algols,
Pascal and C", and then go on to recommend that a novice start by
learning an OO language.

Perhaps I'm missing something here. :)

AHS
 
M

Martin Gregorie

I'm sort of curious as to why you'd say on the one hand that "the OO bit
would have been a lot harder without previous experience in the Algols,
Pascal and C", and then go on to recommend that a novice start by
learning an OO language.
If the Algols and Pascal were still cutting edge languages I'd have
recommended them rather than Java. As they aren't, I think Java is the
next best thing. The compiler produces understandable error and warning
messages, the language is good for teaching well structured programming
and the run-time system produces good error messages and stack traces so
the neophyte isn't left scratching his head over a segfault or trying to
dig through a core dump with gdb.

FWIW, the best crash diagnostics I've ever seen came from the Algol 68R
runtime system. Its stack trace equivalent included the names and values
of all variables that were in scope at the crash and a summary of the
path followed through the procedure containing the crash (which branch
was taken in a conditional, the number of times a loop had executed,
etc.). That was mid-70s technology fer chrissakes! You'd think the rest
of the world would have caught up and surpassed A68R by now!

I was tempted to mention C now that there are decent compilers,
especially GNU and its derivatives, but I think its too low level for an
ab initio programming experience because it requires a reasonable
understanding of computing hardware and crash diagnostics are still very
primitive. However, its a good second language and first class for
teaching defensive programming and debugging to budding Real Programmers.
Perhaps I'm missing something here. :)
Not really. I skipped over my reasons for now preferring Java as a
teaching language when I probably should not have.
 
A

Arne Vajhøj

That was my experience also. I had fairly substantial FORTRAN, VAX
assembler, MOS 6502/6510 assembler/machine code (the good ol' Commodore
C64), BASIC (in various flavours), C, and Pascal experience before ever
encountering an OOP language. Oddly enough the order in which I then
learned and used OOP was Prograph, followed by C++, followed by Perl 5,
and then finally Java when it appeared.

In my opinion - and this of course only applies to my experience -
learning procedural programming first helped a great deal when then
faced with OOP.

This is a somewhat classic discussion.

Should new developers go straight to a modern language or would
they benefit from going through the same evolution as programming
languages has gone through.

Many people argue that they should go directly to OO and that they
will learn bad habits by learning a procedural language first.

But I can see some benefit of learning a procedural language first.
And a language like Pascal (not Delphi) could learn people some
good habits.

But most IT educations seems to disagree.

Arne
 
A

Arne Vajhøj

Does anyone argue that they should go directly to functional and that
they will learn bad habits by learning an OO or procedural language
first? :)

Huge portion of CS teachers.

Very few working in IT.

Arne
 
A

Arne Vajhøj

Such viewpoints exist, but not (commonly) in anyone posting
to a java group!

Not in many other groups either.

Functional languages may have a great future ahead for them, but
so far the job ratio OO:functional is around 100:1.

Arne
 
A

Arne Vajhøj

Most people give up programming, and the remainder learn programming.

Hm. Let us get back to that later.

They claim 27%, 30-50% and 10% in first year.

Have anybody told you that the total is 100% and that percentages
lower than 50% can not be called "most"?

Well - somebody should.

And furthermore no matter what size the dropout rate is, then
it does not substantiate your claim that they drop out if
they don't learn programming philosophy before programming.

Arne
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,744
Messages
2,569,484
Members
44,903
Latest member
orderPeak8CBDGummies

Latest Threads

Top