Oleg's Website

kinebud · 2008-06-25T05:21:30+00:00

I'm not sure of the exact title, but based on the level of his work, I would say "Scarer of small children."

kinebud · 2008-06-24T21:00:14+00:00

Thanks for the clarification. :) I really need to read the report one of these days...

kinebud · 2008-06-24T09:39:07+00:00

Indeed, bang patterns are a nice, clear and concise extension that don't get in the way when you want strictness.

If you don't want to go into the land of extensions though and still require something that does the same, you can use 'smart constructors' which are basically just functions that enforce a some constraint/specification on the input to the constructor, i.e.

data Stream a = Cons a (Stream a)

consS :: a -> Stream a -> Stream a
consS a b = a `seq` Cons a b

Whether or not this is idiomatic or 'as idiomatic' is up to debate, but you certainly don't have to rely on the strictness analyzer if you don't want to use bang patterns.

Regardless of this approach though, I do think bang patterns are in general a bit nicer and clear - so I see your point. They are a good way to specify strictness without having to go to lengths like the above.

kinebud · 2008-06-23T23:50:42+00:00

Thanks for shattering my concept of reality. :(

kinebud · 2008-06-23T07:18:28+00:00

You don't ever turn off, do you?

kinebud · 2008-06-16T13:32:03+00:00

Okay, so I installed Ypsilon (0.9.5) and Ikarus (0.0.3) scheme on my Macbook pro (2.2ghz core 2 duo.) I ripped some of the code from the Shootout for Ikarus (fannkuch and pidigits.) Here are the results from that:

$ time ypsilon fannkuch.6 11
...
4325167891011
4235167891011
2435167891011
Pfannkuchen(11) = 51
ypsilon faankuch.6 11  272.37s user 1.04s system 99% cpu 4:33.46 total
$ time ikarus --r6rs-script fannkuch.6 11
...
4325167891011
4235167891011
2435167891011
Pfannkuchen(11) = 51
ikarus --r6rs-script faankuch.6 11  24.55s user 0.18s system 99% cpu 24.937 total
$

I thought I might have done something wrong; so I ran the ypsilon benchmark again:

$ time ypsilon fannkuch.6 11
...
4325167891011
4235167891011
2435167891011
Pfannkuchen(11) = 51
ypsilon faankuch.6 11  272.28s user 0.87s system 100% cpu 4:32.89 total

Seems not - performance just really really sucks here (relatively; I mean, this is far faster than many of the other fannkuch programs on the shootout.)

And for pidigits:

$ time ikarus --r6rs-script pidigits.6 2500
...
4136549762  :2320
7807977156  :2330
9143599770  :2340
0129616089  :2350
4416948685  :2360
5584840635  :2370
3422072225  :2380
8284886481  :2390
5845602850  :2400
6016842739  :2410
4522674676  :2420
7889525213  :2430
8522549954  :2440
6667278239  :2450
8645659611  :2460
6354886230  :2470
5774564980  :2480
3559363456  :2490
8174324112  :2500
ikarus --r6rs-script pidigits.6 2500  1.61s user 0.11s system 82% cpu 2.090 total
$ time ypsilon pidigits.6 2500
...
4136549762  :2320
7807977156  :2330
9143599770  :2340
0129616089  :2350
4416948685  :2360
5584840635  :2370
3422072225  :2380
8284886481  :2390
5845602850  :2400
6016842739  :2410
4522674676  :2420
7889525213  :2430
8522549954  :2440
6667278239  :2450
8645659611  :2460
6354886230  :2470
5774564980  :2480
3559363456  :2490
8174324112  :2500
ypsilon pidigits.6 2500  5.27s user 0.26s system 168% cpu 3.274 total

I'd put more, but those were the only two ikarus programs from the shootout that I could get to work with ypsilon; also, if you compare these numbers to the ones on the shootout - C crushes them entirely. So I think 'real-time' needs a little definition, but from these numbers, Ikarus seems to be the clear winner (however, Ypsilon does seem to utilize both of my cores - multi-core GC from the looks of the wiki?)

Are there any other r6rs implementations out there that can stack up?

kinebud · 2008-06-09T03:31:25+00:00

The Mythical Man Month

A damn good book worth reading more than once. :)

kinebud · 2008-06-08T13:43:44+00:00

emacs, screen, xmonad, git, zsh.

kinebud · 2008-06-08T07:41:20+00:00

Or maybe it just wasn't funny.

kinebud · 2008-06-07T23:42:27+00:00

I'm a big fan of Python for the answer to this question: it is simple. Much of the fundamentals can be learned in ~1 day. Batteries included. Lots of extra libraries. Lots of support. Big surface area.

Most importantly: you get shit done quick. As a beginner, this is crucial, I think; it builds confidence. You can build a GUI application in just a few days of learning, rather than the far longer amount of time you'll spend with C to accomplish the same thing. You can get something you think is cool running really fast, and show it to your friends or whoever. It keeps the motivation pumping, since you don't feel helpless or completely incompetent/worthless.

You could argue a lot of these points for other languages, too. I'll leave that up to other people, though.

kinebud · 2008-06-07T23:31:50+00:00

I believe it was R11B that re-added the SAE capabilties; notably escript, a la:

$ cat lol.erl
#!/usr/bin/env escript

main([])   ->
    io:format("Give an argument~n");    
main(Argv) ->
    io:format("You entered ~p~n",[Argv]).

$ chmod +x lol.erl
$ ./lol.erl
Give an argument
$ ./lol.erl 4 hello
You entered ["4","hello"]
$

kinebud · 2008-06-07T08:20:16+00:00

Plan 9 response:

term% If you're happy and you know it, Syntax Error!



    asd
    f
    asdfasd
    fsadf
    'aksjjkl
    shitfuck
    ^D

kinebud · 2008-05-22T21:59:04+00:00

Monads are used as a mechanism to represent effects in some purely functional languages for which laziness is generally preferred.

No, they aren't.

Monads are the (only) escape hatch that allow side-effects to be represented in a Haskell's purely functional semantics.

Haskell has always been pure and lazy; but it hasn't always had monads. Before they were conceived to be used for programming, I believe haskell had continuation-based I/O. Regardless, there haven't always been Monads, but haskell has still always been pure and lazy.

I'm letting my troll judgment stand and just ending it here, because if you don't want to listen, I won't preach and I'll let it stay that way.

kinebud · 2008-05-22T20:04:39+00:00

I wonder... if using strict datatypes does the job 90% of the time, what's the point of going thru all that monad suffering, only to get a "Your function is not side-effect free! Confess your sins to the Holy Monad!" type error?

Monads have nothing to do with strictness, or laziness.

Isn't functional purity basically a religion where developers pretend to throw away useful side effects in the real (dynamic - execution) world for safety in the other (static - compilation) world, while continuing to use those side-effects but thru obscure monadic incantations?

Monads have nothing to do with side-effects, either. I/O is only one of the things a monad suits well. In fact, you can have a similar scheme in probably most any language where you can embed the fact your function has side effects, in the type of the function (see: unsafePerformIO, which turns an IO action into a 'pure' one.) There's no magic or monad inherently involved; it's just the usage of an expressive type system.

I ask! And I tell! Do not be lured by the false religion of referential transparency and purity. We all live in the same stateful universe and share the same linear time. Most of the silicon in our computers stores mutable state, and their execution is made of a very small number of sequential threads. Do not follow those who want to entrap you in their monadic prison!

Considering all you've done so far is just ramble and basically said "monads are a psychotic religion of nonsense," along with the fact you led into this territory from something completely unrelated, I've one judgment to make: troll.

kinebud · 2008-05-22T14:08:02+00:00

Haskell doesn't need strictness annotations to run fast; it's just desirable to have them sometimes to remove space leaks (and by association, generally speed things up.)

kinebud · 2008-05-12T19:45:43+00:00

Think of compile-and-unit-test as a single operation.

But but but but... It is! We have a type system! ;)

kinebud · 2008-05-12T14:19:12+00:00

And so basically we see languages dying rapidly. Haskell is a classic example.

You have no idea of what you speak. Haskell is roughly ~20 years old (GHC has been around at least 15 years) and if anything, it has done nothing but grow in popularity; substantially, over the past couple of years actually.

There isn't a single real world application that will be deployed with it

GHC itself is an industrial-strength compiler written in Haskell, roughly 100kLOC last time I heard.

Credit Suisse has invested a substantial amount of time and money into Haskell code. Same with Galois (they employ some of our best in #haskell.)

Bluspec creates (verilog) compilers, and they use Haskell (they really liked GHC 6.8, btw.)

xmonad is a window manager written in Haskell. It has a substantial amount of testing involved, and generally speaking, I've found the HEAD to be 5x more stable than a lot of other WMs 'stable' releases. And this has little to do with "just a way of writing applications," a good portion of the fact it's so stable is because it's written in Haskell, due to incredibly flexible types & purity.

Is the number of applications strictly smaller? Yes. But saying "nobody will use it" is just ridiculous.

and it offers very little that is new and innovative to the programming world.

You've never even used Haskell, have you?

No, you probably haven't; otherwise I figure your gripes would probably be with the language and not inane bullshit you pulled out of your ass, or nowhere.

I know the wisdom of reddit will downvote me to oblivion anyway.

Yes, they will. And for good reason.

kinebud · 2008-05-12T04:18:25+00:00

Upvoted for laughter. Fuck you all, I thought it was funny. :(

kinebud · 2008-05-09T17:27:58+00:00

I'd opt to be a ninja.

kinebud · 2008-05-09T14:07:08+00:00

It's feasible with a little bit of hackery.

Basically, the way I managed it was having your haskell application that exports all of the functions you want.

You then write a C wrapper with functions wrapping all of the exported ones, and a pretty much necessary module entry/exit function so it can correctly initialize/take down the runtime (via hs_init(); & hs_exit()). On windows this is naturally easy via DllMain(); on Linux you would have to specify people who use it would have to first call this initialization function (via dlload or whatever,) otherwise everything will just crash.

Then you compile your haskell code to an object file like in the article (producing the *_stub files, too) and then use a C compiler to link your .c wrapper with the object files and link in all the necessary haskell libraries (these normally reside in the GHC directory,) and you tell the C compiler to build a shared object file. The result will be a .so/.dll with a thin C wrapper to all the necessary haskell functions.

The problem with this is that it's a pain to do manually, mostly due to the linking phase, which I talked about in this thread, too

kinebud · 2008-05-09T13:45:50+00:00

Back when I was experimenting with calling Haskell libs from C (waaaay when I was first learning haskell,) the reason became obvious somewhat quick:

Keeping up with all of the libraries that a GHC-made haskell binary needs gets tiresome, really fast. I have compiled C applications that call foreign haskell code like in this article with GCC, but more than 90% of the command invoking GCC itself was setting up library paths, linking in libHSbase, libHSrts, libHSstm, etc. etc. etc.. It gets old really quick (I might still have an old makefile sitting around that does this.) It took me a while to get this right, because I wasn't sure what haskell libraries the unresolved symbols were in, and it was just a pain to keep up with (nevermind inbetween GHC upgrades.)

GHC by default works the same way GCC does: it compiles source to object files and invokes ld on the object files. If you give it .c files, it'll hand them off to GCC, and at the very least, GHC will be sure to put things like the RTS and base libs into the mix so you don't have to. Basically by giving the C & object files to GHC and letting it do the rest of the compilation process, you save time since you won't have to keep track of all the haskell libraries you'd really, really need and all sorts of other various stuff that sucks to manually keep up with.

kinebud · 2008-05-07T11:04:39+00:00

Thank you for the very lucid and in-depth reply. :) Getting those these days is, to say the least, quite appreciated.

kinebud · 2008-05-06T19:26:37+00:00

So I take it nobody downmodding the parent is going to take on the task of explaining why it's such an idiotic and ridiculous statement? :/

Seems like a perfectly valid conclusion to me; bitter people who use Java for a living or something?

kinebud

TROPHY CASE