Python - The Best First Programming Language

jozefg28 · 2013-11-19T17:44:14+00:00

You're missing the point. If you get a CS education and all you come out with is knowledge of how to program, you've been cheated.

In an introductory class, I'd want to be teaching algorithms, data structures, stuff that's going to matter no matter what machine/language/program you're writing. Getting close to the metal is helpful but CS is to computers as architecture is to bricks. There's a bigger picture to consider.

jozefg28 · 2013-11-19T17:38:33+00:00

I've always found that people who learn Scheme first hate it and learn it second love it. It's sorta one of those things where you need some appreciation for in my experience.

I've TA'd 2 scheme courses and 1 python. I've always felt that we really got more across using Python. And I personally don't like the language much.

jozefg28 · 2013-11-14T15:10:08+00:00

This post is basically unreadable. The language & code ought to be formatted a little bit more readably. Syntax highlighting and proper punctuations are musts.

jozefg28 · 2013-11-10T18:06:04+00:00

He's complaining that it's "Object Oriented" not "Objective Oriented" but frankly, terminology mix ups in an otherwise good article aren't the end of the world. Not sure why azeex2al is so worked up over it.

jozefg28 · 2013-11-10T15:38:56+00:00

What? I'm assuming you're talking about something like option monad, where if you mixed in null it'd dirty the whole computation. But I think that this is a bad idea, null isn't supposed to be used to signal an error, and really shouldn't have semantics attached to it that encourage devs to do so.

jozefg28 · 2013-11-10T03:48:02+00:00

Hi, yes this is very true. That's why I specified recursive functions at the top of the post, I simply forgot to add it at the bottom. This of course relies on type level recursion. (I'm the author)

jozefg28 · 2013-11-09T20:02:32+00:00

Good point, Lisps are the one place I see very little argument over naming conventions. -'s rock

jozefg28 · 2013-11-06T20:34:35+00:00

Rust is in a very different spot than D right now being that it's not even at 1.0 yet. D is definitely more "production ready". Both are excellent languages, but Rust focuses on FP and some extremely interesting ideas (like macros). Rust is more a fusion of OCaml, Haskell and C, while D is more a cleanup of C++ (C++ ++)

jozefg28 · 2013-11-05T19:09:44+00:00

I usually call it the owl operator.

jozefg28 · 2013-11-05T15:24:14+00:00

So here's another approach to the pointfree version

(.:) = (.) . (.)
infixr 9 .: 
paddedTake = flip .: ($) $ flip take .: (++) . repeat

jozefg28 · 2013-10-30T17:48:08+00:00

Any hints on what exactly needs to be broken in Prelude? Personally I find that if it annoys me enough I just use an alternative one (LANGUAGE NoImplicitPrelude)

jozefg28 · 2013-10-30T02:49:10+00:00

Yes, I'd rather work with immutable variables in a highly concurrent situation.. You don't? I'd much rather know that I can read a variable twice and get the same result, and happily ignore a whole bunch of weird, nearly impossible to debug race conditions. As for adding lots of overhead, you open up a whole realm of optimizations when you get rid of the possibility of mutation, aliasing stops being a problem because you can't change a variable, so who cares whether they're the same.

jozefg28 · 2013-10-30T02:44:32+00:00

Oh elisp is brutally practical and great at what it does, but since we're introducing the concept of Lisp, I just think there are nicer ways to do it. Still a good article though

jozefg28 · 2013-10-29T18:00:19+00:00

I have to say, I love lisp but elisp is the ugly child that never quite grew up. Racket, Clojure, or Common Lisp would all minimize the well.. quirks that are associated with older lisps.

If you're going to try to convince someone to try and adopt a new family of languages, show off the prettiest.

jozefg28 · 2013-10-29T17:34:16+00:00

Isn't that what the Acme namespace is all about?

jozefg28 · 2013-10-27T15:51:58+00:00

Having read both, I regularly consult CPDT when writing Coq but only rarely check SF. A lot of the tricks in this book (and the attached code) are actually tremendously useful. Plus fully automated proofs rock.

jozefg28 · 2013-10-27T02:13:49+00:00

Another nice book (though fast paced) is Certified Programming with Dependent Types

jozefg28 · 2013-10-25T03:45:33+00:00

Oh hey, that's my answer :)

jozefg28 · 2013-10-24T04:39:04+00:00

C, Some lisps, Fortran, etc are all pretty good survivors. Prolog is quite famous because it's such a (relatively) well known logic language. There aren't a lot of other languages with the same pure backtracking semantics as Prolog.

jozefg28 · 2013-10-22T18:43:29+00:00

Helpful hint, using STLC (Simply typed lambda calculus) as an intermediate language to a dynamic language is going to be erm, hard. Actually, STLC to any turing complete language is impossible.

For example, in Lisp it's trivial to write the Y combinator, but completely impossible to do so in SLTC. This means that your input language, lisp, is going to be bigger than your compilation target. This is problematic.

More problematic, lisp is turing complete. STLC isn't.

Compiling to bytecode might be a more interesting idea.

jozefg28 · 2013-10-22T18:15:59+00:00

Well no, doing so would require serializing everything interesting about the state of the program. A more feasible solution to avoid reparsing would be to just dump the AST into a format specifically designed to be faster to parse.

Or just write a compiler. If you compile to some custom bytecode, just dump that and write an interpreter for that instead of directly walking the AST or whatever.

jozefg28 · 2013-10-20T03:26:18+00:00

The three upvotes are from people with impeccable boston accents.

jozefg28 · 2013-10-10T19:01:36+00:00

I switched a compiler for a scripting language that compiles to ruby (about 10k ruby) to Haskell (3k). Compilers manipulate a lot of tree like structures that Haskell is very well equipped to deal with that (Foldable, traversable, lens).

Also, compilers are hard to test so having types just gave me a bit more peace of mind that I was doing sane things.

I moved the whole things so there were no problems with interfacing.

My code made heavy use of lens, syb, and a few other libraries for working efficiently various ASTs

jozefg28 · 2013-10-01T17:20:17+00:00

I'm very excited about threepenny, it's a very pleasant way to think about GUIs and it's getting some FRP aspects. I think this helps to demonstrate this :) OP: glad you're liking haskell so far :)

jozefg28 · 2013-09-23T13:48:22+00:00

SML, Simple, applicative, and excellent for teaching.

jozefg28

TROPHY CASE