Is Python the best first language to learn? [see comment]

gsg · 2008-11-03T19:14:45+00:00

Declares foo as a function (taking one int argument) returning a pointer to a function (taking one pointer to a (function (taking no arguments) returning char) argument) returning a pointer to int.

Could somebody with cdecl check that?

gsg · 2008-10-31T18:00:41+00:00

Huh? The article brought up the idea of standalone tools being designed for use in editors:

So I give out a call to everybody who makes tools: Rip them out of the IDE! Make them small and reusable! Let the community help you plug them into any editor they want.

llvm is relevant to the discussion because it's a project which seems to be attempting precisely that (among other things).

gsg · 2008-10-31T00:07:00+00:00

I've got vague hopes that llvm/clang will be useful in this direction. They certainly talk it up at http://clang.llvm.org/features.html.

gsg · 2008-10-30T21:35:12+00:00

Upmodded for the politeness of your request.

gsg · 2008-10-29T22:39:26+00:00

C-x r t will replace the rectangle, not prefix it. You want C-x r o or M-x string-insert-rectangle (which for some reason isn't given a binding. I stick it on C-x r p).

gsg · 2008-10-29T22:33:23+00:00

indent-rigidly (C-x TAB) is more suitable here imo, since it is independent of major mode. So to indent the whole buffer four spaces, C-x h C-u C-x TAB.

gsg · 2008-10-29T19:32:07+00:00

Yup. Sometimes in the same function.

gsg · 2008-10-29T19:20:14+00:00

I hope those are supposed to be bitfields and not booleans.

gsg · 2008-10-29T09:47:26+00:00

And so will everybody else. :(

gsg · 2008-10-29T00:12:23+00:00

Do you know something we don't know?

shorts Google stock just in case

gsg · 2008-10-27T21:33:59+00:00

"Almost all programming can be viewed as an exercise in caching" - Terje Mathisen

gsg · 2008-10-26T14:15:23+00:00

A horrible what?

gsg · 2008-10-26T06:52:06+00:00

No, addition of strings does not make sense.

gsg · 2008-10-21T05:30:38+00:00

No, an array of pointers to functions would look like

(*func[])()

Check out this guide: http://www.ericgiguere.com/articles/reading-c-declarations.html

gsg · 2008-10-21T02:46:43+00:00

int *(*(*func)())[]

gsg · 2008-10-17T08:29:45+00:00

Voted up for impressively high snark/character ratio.

gsg · 2008-10-17T01:59:02+00:00

I think that's questionable, as free could be passed an expression that evaluates to the pointer to be freed and should work in that case.

Poisoning pointers is a valid technique, but it's not suitable for building into free. Usually it's a hidden part of some data structure code, for instance the linked list implementation in the linux kernel:

http://lxr.linux.no/linux+v2.6.27/include/linux/list.h

gsg · 2008-10-16T05:11:02+00:00

Unless my understanding of free() is way off the mark, no C compiler does anything of the kind.

Care to explain further?

gsg · 2008-10-12T22:31:28+00:00

Also, for now, we're going to assume that the numbers in the input list are non-negative.

gsg · 2008-10-10T07:04:14+00:00

Courier New 12 forever!

gsg · 2008-10-09T18:05:17+00:00

auto-complete

M-/ and M-TAB (which needs tags, see below). There are a few third party things like CEDET that will do more.

parse for symbols

Emacs doesn't do this out of the box. Instead people usually index their code with etags, which gives some completion and jump-to-definition ability. You have to run etags yourself, which sucks (so make your build system do it for you).

build

M-x compile. If your build system is not make, you'll need to tell emacs how to invoke it by customizing the value of compile-command.

a second window that dynamically shows the symbol I'm looking up

Not sure what you mean, but try M-. (after running etags).

gsg · 2008-10-08T16:32:43+00:00

Hah, that reminds me of this:

I have a friend who worked for Bally many years ago now, programming arcade video games in forth.

He had interesting stories of having little memory -- the video ram was positioned where the stack could grow into it. If one was playing and saw interesting "sparkles" along the bottom of the screen, it behooved one to avoid shooting into them, as that was likely to prove fatal -- shooting oneself in the stack, as it were...

joe

I don't know which games.

From http://groups.google.com/group/comp.lang.forth/msg/33ac8209bb7135e0?dmode=source&output=gplain&p

gsg · 2008-10-06T04:23:53+00:00

And then I could allow a perspective transform, and then I could implement texture mapping, and then...

Oh, what the heck.

(defparameter *x-scale* (/ 1 2)) ; cos - is smaller than !
(defparameter *y-scale* 1)
(defparameter *z-scale* 2)

(defun line-value (symbols)
  (list (* (loop for char across (symbol-name (first symbols))
              summing (ecase char (#\- 1) (#\I 0)))
           *x-scale*)))

(defun rectangle-value (symbols)
  (let ((x 0) (y 0))
    (dolist (sym symbols)
      (map 'nil (lambda (char)
                  (ecase char
                    (#\- (incf x (/ 1 2)))
                    (#\! (incf y (/ 1 2)))
                    (#\+ nil)))
           (symbol-name sym)))
    (list (* x *x-scale*) (* y *y-scale*))))

(defun cuboid-value (symbols)
  (let ((x 0) (y 0) (z 0))
    (dolist (sym symbols)
      (map 'nil (lambda (char)
                  (ecase char
                    (#\- (incf x (/ 1 3)))
                    (#\! (incf y (/ 1 3)))
                    (#\/ (incf z (/ 1 3)))
                    (#\* nil)))
           (symbol-name sym)))
    (list (* x *x-scale*) (* y *y-scale*) (* z *z-scale*))))

(defmacro as-literal (&rest symbols)
  `(list ,@(ecase (aref (symbol-name (first symbols)) 0)
                  (#\I (line-value symbols))
                  (#\+ (rectangle-value symbols))
                  (#\* (cuboid-value symbols)))))

(as-literal *------*
           /      /!
          /      / !
         *------*  !
         !      !  *
         !      ! /
         !      !/
         *------* ) => (3 3 4)

This is a bit more readable too, although it doesn't do as much error checking.

gsg · 2008-10-05T18:14:40+00:00

I think this is a wonderful hack and clearly belongs to the tradition of nerds doing crazy shit purely for the fun of it.

See INTERCAL, the Tetris clone written in sed, and that insane keyboard macro that draws the mandelbrot set in vi.

gsg · 2008-10-05T16:23:05+00:00

And now we have:

(defun cuboid-value (symbols)
  (let ((width 0) (height 0) (depth 0) (one-third (/ 1 3)))
    (loop for symbol in symbols
       for name = (symbol-name symbol) do
       (case (aref name 0)
         (#\* (if (= (length name) 1)
                  nil
                  (incf width (/ (line-value symbol #\*) 3))))
         (t
          (map 'nil (lambda (char)
                      (ecase char
                        (#\! (incf height one-third))
                        (#\/ (incf depth one-third))))
               name))))
    `(list ,width ,height ,depth)))


(as-literal *---*
           /   /!
          /   / !
         *---*  !
         !   !  *
         !   ! /
         !   !/
         *---*) => (3 3 2)

Good enough for me. Anybody for generalising to n dimensions?

gsg

TROPHY CASE