On Wed, Oct 13, 2010 at 4:16 PM, Gabriel M. Beddingfield <gabrbedd(a)gmail.com I might also add that one very useful resource on linux is the GNU libc manual. For some types of projects, you won't need anything more than this: http://www.gnu.org/software/libc/manual/

Gabriel M. Beddingfield wrote: I've been using C++ for nearly 20 years (including the last 8+ years professionally) and I am nowhere near mastering it. In fact, when you add in commonly used things like STL and Boost, I find the language is growing faster than I'm learning it. If you get serious about programming, its important to know more than just C and C++. For many tasks, garbage collected languages with stricter type systems than C and C++ are a better fit. Langauges like Python, Ruby, Ocaml and Haskell. Even Java!!! Erik -- ---------------------------------------------------------------------- Erik de Castro Lopo http://www.mega-nerd.com/

On Thu, 14 Oct 2010, Chris Cannam wrote: Yes, I was trying to keep it simple. But I think in 2 years you can at least "hold your own." :-) Did you mean to say "not to be too comfortable" ? If so, I totally agree. :-) -gabriel

How about the D programming language? 2010/10/14 Joshua Boyd <jdboyd(a)jdboyd.net>et>:

Erik de Castro Lopo wrote: is some confusion about type systems, in particular strict vs strong typing. Type systems can basically be mapped onto two axes; strong | | | dynamic ----------+---------- static | | | weak Strong type systems prevent you from doing things that do not make sense like adding an integer and a list. For instance, in Python, gives an error like "unsupported operand type(s) for +: 'int' and 'list'". Weak type systems allow things that don't make sense (possibly with a user provided type cast). For instance in C: float test (GLIst *list) { int x = 10 ; return x + (int) list ; } the above makes no sense whatsoever, but the compiler accepts the programmers word that this is in fact what the programmer wants. Purely static type systems are ones where all the types are checked at compile time and the run time objects contain no type information and no type checking is done at run time. Purely dyanmic type systems are ones where every run time data object carries around its type and all the type checking is done at run time. With the above axes set up you can have languages like C with weak static types, Haskell with strong static types and Python with strong dynamic types. I don't know of any language that can really be said to have weak dynamic types. Furthermore, most dynamically types languages have a small amount of static type checking built in, but this is usually a by product of syntax checking. Similarly, in a statically typed langauge its possible to implement a library with an object type where the type checking for operations on those objects is carried out at run time. Finally, many people assume that all strictly typed languages require the programmer to explicitly define the types of everything. Fortunately, this is not the case. There are a whole family of languages that use Hindley-Milner type inference to infer the types of all objects from the context. These languages include Ocaml and Haskell. HTH, Erik -- ---------------------------------------------------------------------- Erik de Castro Lopo http://www.mega-nerd.com/

Excerpts from Erik de Castro Lopo's message of 2010-10-14 22:44:03 +0200: Thanks for this clarification Erik, it's a topic lots of people are confused about, if they have any idea at all. Your explanation with the axis makes sense, thanks. Philipp

On Fri, 15 Oct 2010 10:20:45 +0100, Chris Cannam wrote Pretty much at the same location that Python and Ruby. For an example of really weak dynamic typing have a look at the old TCL - everything was internally represented as a C string (null-terminated character array). RalfD -- R. Mattes -- Systemeinheitsstreichler Hochschule fuer Musik Freiburg rm(a)inm.mh-freiburg.de

Chris Cannam wrote: Yes, Perl is not much different in this regard from those two; strict runtime type checking. Its been a long time since I looked at Perl, but I think that Perl does small amount of compile time checking; the language distinguishes between scalars, arrays and dictionaries by (from memory) use of $scalar, @array and %dict. However, elements within an array like: @array = ( 1, "two", $value ); are all just objects with type information to distinguish between the int, string and the scalar. Exactly. The types are checked and an implicit conversion from int to string is performed on $x and then the '+' operator then concatenates the two strings. Cheers, Erik -- ---------------------------------------------------------------------- Erik de Castro Lopo http://www.mega-nerd.com/

On 10/14/10 00:11, Folderol wrote: I concur. Start with C. a rule of thumb: for GUIs and complex structures: C++ ;for algorithms: C Apart from some book, the 'manpages-dev' package (section 3 manual pages) come in really handy. eg `man 3 printf` gives you a full overview and even example code. After you grasped some basics, reading other PPL's code is something that helps a lot. I've started some small off-list online tutoring; walking through JACKd's simple_client.c and Fons's jnoise source with Philipp Ueberbacher recently and can post our conversation if you're interested. I recently recommended this one to Philipp: http://cslibrary.stanford.edu/102/PointersAndMemory.pdf It's an nice read and I especially like the first sentence: "There's a lot of nice, tidy code you can write without knowing about pointers. But once you learn to use the power of pointers, you can never go back." best, robin

Hi Robin, I would be interested! I started learning C and then started to learn C++ and then I stopped, because I lacked time. Now i'm encouraged to improve C and really use it. Best, Bjoern

On Wed, Oct 13, 2010 at 11:11:41PM +0100, Folderol wrote: Pointers: make sure you understand them so well that you will love them. Structures: make sure you understand them very well. C++ objects are just structures with some functions added. If this sounds strange, this is the background: - C is very close to what happens in hardware, i.e. to what you processor will be doing. It helps *a lot* to understand things at that level, even if later you will want to use more abstract views. It's a good idea to get some familiarity with a 'clean' processor e.g. the ARM - you will understand that a lot of what it is doing directly maps to pointers. - The C++ world hates pointers and tries to deny their existence by all means, one of them being the concept of 'references'. Which are just pointers in disguise, and the disguise doesn't help to understand them. Nor does their inconsistent syntax. Good luck ! -- FA There are three of them, and Alleline.

. I completely agree, I've dabbled in Lisp and Prolog. My point is that most languages are based around: variables, conditionals, loops, and procedures. There are variations of implementing this, and many additional concepts floating around, but the concepts I listed appear as the base of most languages. I thought it might be better to hold off from introducing predicate calculus and list based coding for a first time programmer. ;-) Happy coding, Tim.

Josh Lawrence wrote: This is an interesting point. Yes, the vast majority of the small useful utilities that run on a Linux machine have historically been written in C. In addition, OS kernels, device drivers and speed critical tasks are usually written in C. That means that any professional programmer or dilligent amateur programmer should know C. However, for the small user space utilities, C is not the only game in town. As part of my day job I ocassionally write similar small utilities to run on our kiosk style linux systems. However, I rarely write these utilities in C; C is way too flawed and unsafe a language. Instead, I write these utilities in strict statically typed functional languages like Ocaml and (more recently) Haskell. These languages are higher level so I don't have to worry about things like memory allocation and buffer overflows. They also have safe strings which makes string processing far easier than in C or C++. The standard libraries of these languages have simple, easy and guaranteed safe handling of high level data structures like lists and dictionaries so I don't have the write them from scratch. However, most of the features above are also shared by languages such as Ruby and Python. The big difference is that Ocaml and Haskell programs compile to native binaries (like C and C++) and that the compilers for these languages have a much more strict type checkers (ie they find coding errors) than C or C++. This means that many classes of bugs are found at compile time rather than at run time like they would be for Ruby/Python/etc. The native binaries produced from Ocaml and Haskell programs also tend to run siginificantly faster than byte code interpretted programs written in Ruby/Python/etc. As you might guess from what I've written in this thread, I am quite interested in programming langauge research. From what I have seen of this feild, the vast majority of programming language centered computer science research (ie PhD research and papers in reviewed journals) is done around Haskell and to a lesser extent Ocaml. In summary, since your interest seems to be in improving your knowledge about Linux and how your machine works, C is definitely the language to look at. However, C has many traps, requires strict attention to detail and can be rather unforgiving. Higher level langauges like Python, Ruby, Ocaml and Haskell allow you to concentrate more on the problem than on the details. Good luck. Cheers, Erik -- ---------------------------------------------------------------------- Erik de Castro Lopo http://www.mega-nerd.com/

Ng Oon-Ee wrote: That was definitely true of Haskell 10 years ago, but is becoming less and less true with each passing year. Examples of real world practical programs written in Haskell include the Darcs revision control system [0] and the XMonad tiling window manager [1]. The statement is even less true for Ocaml which is a very practical and pragmatic language for solving real world problems. Erik [0] http://darcs.net/ [1] http://xmonad.org/ -- ---------------------------------------------------------------------- Erik de Castro Lopo http://www.mega-nerd.com/

On Thu, Oct 14, 2010 at 07:26:40PM -0500, Josh Lawrence wrote: Heh, as soon as I saw that subject line, I thought, "Jeez, talk about throwing a lit grenade into the room... fun flamewar undoubtedly to follow, get popcorn." I'd have to vote for Python for a first programming language. Useful clear, easy to read, easy to understand, plenty of examples around, well-documented, and with libraries available to do pretty much anything you might want to do on Linux, even audio processing. A second choice would be... Scheme, since all programming languages are asymptotically approaching Lisp anyway. But you could do much more useful stuff with Python, and apparently even MIT has switched from Scheme to Python for its intro computing class (sacrelidge!). Scheme will melt your brain-- in a good way-- and after I learned it I thought of programming in a whole new way. C is a surprisingly small language, and easy to learn. I still have a copy of the original Kerninghan and Ritchie book introducing C, it's like the size of a small booklet, maybe a hundred pages if that, in fairly large type. C is basically just a portable assembler, or that's what it was written to be. I love C for embedded programming or anything that touches hardware. Learn lots of languages. They're like styles of music: if all you know is jazz, that's great, but better to be able to play reggae and funk and rock and blues an d techno and baroque and gospel and country and salsa too. -ken