00:00:00 --- log: started retro/11.02.27
00:45:12 --- join: Pline (~Aashim@61.153.16.162) joined #retro
00:45:12 --- part: Pline left #retro
00:58:04 --- join: Mat2 (5b4085ac@gateway/web/freenode/ip.91.64.133.172) joined #retro
00:58:09 <Mat2> hi
01:00:04 <Mat2> oPless: The CTO of XMOS was the chief architect for INMOS transputer, the XMOS is not a 0 operand stack-cpu but its instruction set allowing stack processing without extra effort
01:02:11 <Mat2> and the four "links" of each core share some ideas from INMOS "interconnect channels". New is the build in sheduler for each core, supporting asynchronous threads
01:02:47 <Mat2> I think it's a nice architecture
01:06:55 <Mat2> ciao
01:06:59 --- quit: Mat2 (Quit: Page closed)
03:26:29 --- log: started retro/11.02.27
03:26:29 --- join: clog (nef@bespin.org) joined #retro
03:26:29 --- topic: 'Retro Language | http://retroforth.org | Logs @ http://bit.ly/ayTmLI | Release 10.7.6 @ http://bit.ly/gSLQdD | Fossil Repo @ http://rx-core.org | Corpse Blog @ http://rx-core.org/dev/corpse | Forums @ http://forthcommunity.com | Donations @ https://www.wepay.com/donate/179527'
03:26:29 --- topic: set by crc!~quassel@li125-93.members.linode.com on [Sat Jan 29 13:39:05 2011]
03:26:29 --- names: list (clog SimonRC +foucist yiyus oPless scj @ChanServ @crc docl cfa)
07:39:43 <foucist> docl: that (+) symbol is XOR so shouldn't your ch and maj word be using 'xor's ?
07:47:29 <crc> I updated the various retroforth mirrors, and made the old wiki editable again
07:47:41 <foucist> crc: what does the stack comment here mean?   t: <<   ( xy-n  )  <<,   ;      t: >>   ( xy-n  )  >>,   ;
07:47:55 <foucist> crc: shouldnt >> be taking in 2 values, 1 being n ? 
07:47:59 <crc> takes two elements, returns 1
07:48:16 <foucist> yeah but wouldn't the stack comment be xn-n ?
07:48:18 <foucist> er
07:48:26 <foucist> xn-x
07:48:38 <foucist> takes in a value & integer, returns the modified value..
07:48:40 <foucist> xn-y ?
07:49:03 <foucist> xy-n implies two separate values taken in, and some integer returned
07:49:05 <docl> foucist: yeah I was reading the specs and it said that OR and XOR give the same result. heh, I should do the empirical test.
07:49:19 <crc> foucist: would be correct
07:49:32 <crc> takes a two values in and returns a new value 
07:49:37 <foucist> crc: but that's not what >> does, it doesn't return an integer, it returns a modified variable
07:49:46 <crc> n = (x >> y)
07:49:49 <foucist> X Y etc represent variables
07:49:59 <foucist> N represents a count
07:50:13 <crc> +------------+------------------------------------+
07:50:14 <crc> | x, y, z, n | Generic numbers                    |
07:50:14 <crc> +------------+------------------------------------+
07:50:14 <crc> | q, r       | Quotient, Remainder (for division) |
07:50:14 <crc> +------------+------------------------------------+
07:50:15 <crc> | ``"``      | Function parses for a string       |
07:50:17 <crc> +------------+------------------------------------+
07:50:19 <crc> | q          | Quote                              |
07:50:21 <crc> +------------+------------------------------------+
07:50:23 <crc> | a          | Address                            |
07:50:26 <crc> +------------+------------------------------------+
07:50:28 <crc> | ``$``      | Zero-terminated string             |
07:50:30 <crc> +------------+------------------------------------+
07:50:32 <crc> | c          | ASCII character                    |
07:50:35 <crc> +------------+------------------------------------+
07:50:37 <crc> | f          | Flag                               |
07:50:39 <crc> +------------+------------------------------------+
07:50:41 <crc> | t          | Type constant                      |
07:50:43 <crc> +------------+------------------------------------+
07:50:45 <crc> | ...        | Variable number of values on stack |
07:50:48 <crc> +------------+------------------------------------+
07:50:54 <crc> I'd have used 'a' if it expected a variable
07:52:44 <foucist> looks like ansi forth uses # for count
07:52:48 <foucist> i guess i was wrong  http://www.forth.org/forth_style.html
07:53:01 <foucist> and the other forths use n1 n2 n3 i guess
07:53:04 <foucist> WEIRD though
07:53:09 <foucist> because when i see shit like
07:53:41 <foucist> nevermind
07:55:22 <foucist> crc: in science papers it's often n that is a count, and x/y etc that are varibles heh
07:55:35 <foucist> like in that page you linked before @ http://csrc.nist.gov/publications/fips/fips180-2/fips180-2.pdf
07:55:40 <foucist> SHR
07:55:40 <foucist>  n
07:55:41 <foucist> (x) = x >> n
07:57:00 <crc> My stack comments and code styling guidelines are documented (see The_Retro_Language.rst, or http://retroforth.org/pages/?CodeStyle for the wiki version of this section)
07:59:03 <foucist> : shr ( xn-y ) repeat >> again ;
07:59:22 <foucist> does that work ? it'll repeat >> n times on x ?
07:59:24 <crc> no
07:59:36 <crc> that'll crash, since repeat/again is an endless loop
07:59:59 <foucist> what takes a count and repeats for that amount?
08:00:21 <crc> the times, iter, and iterd combinators
08:00:56 <foucist> cool
08:01:25 <foucist> : shr ( xn-y ) iter >> ; ? 
08:01:28 <foucist> er
08:01:32 <foucist> iterd >> ; 
08:01:36 <crc> : shr ( xn-y ) tuck [ over >> ] times nip ;
08:02:05 <crc> assuming you want to repeat "x >> n", n times
08:02:08 <foucist> what's wrong with : shr iterd >> ; ?
08:02:11 <crc> times           (   nq-     )  Run quote (n) times
08:02:12 <crc> iterd           (   nq-     )  Run quote (n) times and push counter to stack
08:02:12 <crc>                                each time. Counts down.
08:02:12 <crc> iter            (   nq-     )  Run quote (n) times and push counter to stack
08:02:12 <crc>                                each time. Counts up.
08:02:26 <crc> 1) iter and iterd push a counter to the stack
08:02:33 <crc> 2) they take a quote off the stack
08:02:45 <foucist> crc: your http://sprunge.us/MgMG  doesn't say iterd pushes counter to stack each time
08:02:52 <foucist> what's the diff between iterd & iter? 
08:02:57 <docl> up vs down
08:03:03 <foucist> oh
08:03:19 <docl> 3 elements x y z
08:03:19 <docl> : !each [ getc dup putc !tib 0 tib 1+ ! tib find drop @d->xt ! ] times ;
08:03:20 <docl> 1 2 3 3 !each zyx
08:03:39 <crc> foucist: 
08:03:39 <crc>     : iterd (  nq-  )
08:03:40 <crc>       over 1 >= [ swap for tors swap dup dip next drop ] [ 2drop ] if ;
08:03:40 <crc> Run quote (n) times and push counter to stack each time. Counts down.
08:03:59 <crc> that's from the link you just pasted; it does say that the counter is pushed :)
08:04:12 <foucist> crc: oh i was assuming the sentence above was applying to iterd
08:04:21 <foucist> woopsie
08:04:24 <crc> ahh, sorry
08:04:31 * crc makes a note to clarify this
08:04:58 <foucist> crc: ti
08:05:22 <foucist> crc: i rpobably would've noticed if i was reading through the whole thing properly
08:05:46 <foucist> but since i looked directly at iterd..
08:06:32 <foucist> crc: a clarification might be "times runs quote (n) .." 
08:06:58 <foucist> i.e. throw the name of the word into the beginning of each sentence maybe?  not sure if it works
08:07:26 <crc> done: http://sprunge.us/geDW (and in the Commentary.txt in the repo as well)
08:10:19 <docl> better approach than above
08:10:19 <docl> 3 elements x y z
08:10:20 <docl> 1 2 3 x !+ !+ !
08:19:01 <crc> docl: if you have a larger array to initialize, each@ might work better:
08:19:01 <crc> 1 2 3 x 3 [ ! ] ^types'BUFFER each@
08:20:33 <foucist> docl:   : shr >> ;  :P  (ignore the one above lol)
08:20:49 <docl> heh
08:21:41 <docl> crc: neat
08:22:46 <docl> crc: as far as arity goes, should I do ( x y z ) or ( z y x ) for my functions?
08:23:20 <docl> well I guess it's ( zyx- ) vs ( xyz- )
08:23:38 <docl> or rather ( zyx-n ) vs ( xyz-n )
08:24:05 <crc> docl: i generally go with whatever leads to the least stack noise
08:25:22 <docl> hmm. I wonder if I should just juggle since there are only three values. makes it harder to read that way.
08:25:46 <crc> what is the current code?
08:26:03 <docl> 3 elements z y x
08:26:04 <docl> : ch  ( xyz- ) z !+ !+ ! @x @y and @x not @z and or ;
08:26:04 <docl> : maj ( xyz- ) z !+ !+ ! @x @y and @x @z and or @y @z and or ;
08:27:06 <foucist> : rotr ( xn-y) 2dup >> push 32 - << pop or ;
08:27:24 <foucist> docl: have you done rotr yet?
08:27:29 <docl> not yet
08:30:24 <docl> 32 being word size. could replace that with a constant named w in case you want to port to SHA-512 later.
08:32:21 <foucist> well in retro do we have cell sizes or what?
08:32:24 <docl> 32 constant w
08:32:25 <docl> : rotr ( xn-y) 2dup >> push w - << pop or ;
08:32:25 <docl> : rotl ( xn-y) 2dup << push w - >> pop or ;
08:32:54 <crc> foucist: one cell size, 32-bits. Unless you are using an experimental VM with 16-bit or 64-bit cells.
08:33:32 <foucist> crc: do you have a variable that provides the # ? i know some forths do that
08:33:55 <foucist> a constant called 'cell' or something like that?
08:34:01 <crc> no
08:34:13 <foucist> yeah prob not needed
08:35:28 <docl> heh, I guess rotl is not needed for sha256 anyway
08:35:44 <crc> generally not. You have to use an image that matches your VM's cell size, so you shouldn't need to query the cell size normally
08:36:45 <crc> docl: for 'ch', you could get by with one variable:
08:36:45 <crc> : ch ( xyz- ) -rot over !x and @x not rot and or ;
08:36:58 <foucist> crc: have you talked to chuck moore in the last 5 years btw?
08:37:04 <crc> foucist: no
08:37:09 <foucist> you meanie
08:37:11 <foucist> he's a nice guy
08:37:14 <foucist> what do you got against him?
08:37:15 <foucist> jk
08:37:16 <foucist> :P
08:37:31 <docl> crc: good point, x is the only one that gets duplicated in that function
08:38:25 <crc> his work and mine are in two different directions
08:38:45 <crc> nothing against him, except that he hasn't built a version of colorforth that can run on more systems... :)
08:40:05 * docl wonders how hard it would be to port it to ngaro
08:40:35 <crc> colorforth? it'd be a complete rewrite. The only c4th source I've seen is for 32-bit x86 assembly.
08:41:16 <crc> I've dabbled with limited colored forth varients for ngaro in the past, with raystm2 helping to test them. Nothing came of that though.
08:42:33 * docl wonders how much of an advantage color really presents
08:43:31 <foucist> color isn't a big part of it
08:43:39 <foucist> everythign else is radically different
08:43:47 <foucist> even if you decolorized it
08:44:03 <docl> text-entry modes
08:44:17 <foucist> no i'm not talking about the  interface either
08:45:15 <foucist> talkign about stuffl ike : foo jump <zero> ; <one> ; <two> ;
08:45:43 <foucist> or one word running into the next
08:46:08 <crc> retro4-9 were mostly based on colorforth's internal model
08:47:12 <crc> docl:   : ch ( xyz- ) -rot over [ and ] dip not rot and or ;
08:49:20 <foucist> crc: you had open ended ;  once right?
08:49:24 <foucist> like
08:49:26 <foucist> : abs -if
08:49:36 <foucist> : negate - 1 . + then ;
08:49:47 <foucist> so 'abs' also used negate 
08:49:51 <crc> foucist: correct
08:49:57 <foucist> do you still have that?
08:50:02 <crc> not currently
08:50:08 <foucist> any reason ?
08:50:17 <crc> though your negate is wrong. badly :)
08:50:31 <crc> (at least, for retro)
08:51:08 <foucist> yeah that's the colorforth version
08:52:07 <crc> foucist: with the current dictionary structure, it's not all that efficient since I'd have to jump over the header to get to the next function
08:52:11 <foucist> crc: from ehre http://www.greenarraychips.com/home/documents/greg/cf-style.htm
08:52:15 <foucist> at thte bottom heh
08:52:36 <foucist> check out the 'jump into the loop in the middle' one too
08:52:40 <foucist> begin -1 . +
08:52:40 <foucist> delay n -until ;
08:52:53 <foucist> begin -1 . + : delay -until ;
08:53:14 <foucist> pretty weird
08:53:26 <foucist> not even defining the world till the middle of it?
08:53:38 <foucist> well i guess the first part would get defined in some other word
08:53:46 <crc> probably
08:54:04 <foucist> it might be cool to do multiple word definitions in one line
08:54:17 <crc> things like that are interesting, but harder to test for consistancy
08:54:27 <crc> (the loop, not the fallthrough)
08:57:14 <foucist> crc: finish the dl? :P
08:57:28 <crc> yes, a short time ago
08:57:30 <foucist> & hacking teh logs? 
08:57:33 <crc> now freeing up hard drive space
08:57:56 <crc> I haven't synced the logs to my server yet
08:59:10 <crc> I'll do that now
09:00:16 <crc> cleaned logs will be uploaded shortly :)
10:37:12 --- join: Mat2 (5b4085ac@gateway/web/freenode/ip.91.64.133.172) joined #retro
10:37:15 <Mat2> hello
10:56:21 <crc> hi Mat2
10:56:30 <Mat2> hi crc
11:21:38 --- quit: Mat2 (Ping timeout: 272 seconds)
11:36:36 --- join: Mat2 (5b4085ac@gateway/web/freenode/ip.91.64.133.172) joined #retro
11:51:34 * crc is back to editing books. I should probably check to see what's new with MoR (my last update was TSPE, Constrained Cognition, Part 8)
12:03:29 <foucist> howdy Mat2 
12:03:41 <Mat2> hi Foucist
12:04:07 <foucist> crc: btw, speaking of colorforth on ngaro like docl brought up earlier..  i assume colorforth runs on the forthchip, which has 33 opcodes..  so there must be a version out there written in forth
12:04:12 <foucist> perhaps that could be adapted to ngaro easily
12:04:30 <foucist> (i asusme there's a version of colorforth for forthchips..)
12:05:08 <crc> I've never seen source for that released, and the dev boards coming out for the ga144 list an eforth port, not colorforth as being included
12:05:49 <foucist> oh, yeah i read that eforth came out first for it
12:06:02 <foucist> the implication is that colorforth will (or may have by now) be coming out for it
12:07:59 <Mat2> if there exist a colorforth version based upon machine-forth porting would probably an easy step ?
12:08:16 <Mat2> who knows
12:08:24 <crc> not necessarily, but it gives us more to study :)
12:08:38 <Mat2> yeah :)
12:10:25 <Mat2> colorforth makes a lot of sense, specially the compiler simplification, late binding, on demand compiling etc.
12:11:08 <Mat2> add closure support and tail-call optimisation and you get a nice functional forth dialect
12:11:33 <foucist> yeah
12:12:28 <Mat2> *Mat2 is a colorforth fan
12:12:37 <foucist> me too :P
13:53:33 --- quit: Mat2 (Ping timeout: 272 seconds)
14:27:43 --- quit: foucist (Remote host closed the connection)
14:38:09 --- join: foucist (~foucist@ps14150.dreamhost.com) joined #retro
14:38:09 --- mode: ChanServ set +v foucist
15:41:34 <crc> foucist: to allow nestable colon definitions in Retro:
15:41:34 <crc> : t: ahead : here swap ! ; immediate
15:41:34 <crc> &t: rename: :
15:45:25 <foucist> heh
15:49:59 <foucist> crc: ok dl'd the stable retro and ran make..  how do i load a retro file?  ./retro <file.rx> doesn't do anything
15:50:07 <foucist> or rather, how do i just run the file (not load)..
15:50:42 <foucist> hmm, you don't have any documentation links on yoru main retroforth.org page ?
15:51:29 <foucist> nevermind, found the do
15:51:30 <foucist> doc*
15:53:43 <foucist> crc: http://pastie.org/1614988.txt   if i do ./retro --with <thatfile>  it should work right?
16:03:46 <crc> yes
16:04:30 <crc> rename: may not be in the stable release; don't remember at the moment :)
16:06:48 <crc> yeah, stable lacks the rename: function
16:08:32 <foucist> ah i see
16:09:22 <crc> so:
16:09:22 <crc> : : ahead create &.word reclass here swap ! ] ; immediate
16:09:43 <crc> that should work in 10.7.x
16:10:12 <foucist> crc: how do i use retro to run scripts (don't wnat to go into the interpreter?)
16:10:21 <foucist> also the interpreter is weird, it creates a new line for every time i hit space?
16:10:27 <foucist> and has 'ok' on every line
16:10:40 <crc> the interpreter evaluates as you type. it's been like this since I started on 10.x
16:10:54 <foucist> ok
16:11:03 <foucist> how about just runing a script
16:11:19 <foucist> how to use retro for shell scripting for example
16:14:00 <foucist> crc: oh, 11.0 doesn't use puts or . anymore?
16:14:09 <crc> 1) build the vm to look for the image in a known location (see the "GLOBAL" define)
16:14:09 <crc> 2) copy the vm to a location in your path
16:14:09 <crc> 3) load this into the image you'll use:
16:14:09 <crc> : #! 32 accept 32 accept ;
16:14:09 <crc> here ] ; is boot
16:14:11 <crc> here ] ; is ok
16:14:13 <crc> save
16:14:16 <crc> bye
16:14:18 <crc> 4) copy the image to where the script expects to find it
16:14:20 <crc> 5) start the script with:
16:14:22 <crc> #! /path/to/retro --with
16:14:25 <crc> 6) end the script with bye
16:14:27 <crc> foucist: . is now putn in retro11
16:14:29 <crc> puts should work
16:14:50 <foucist> ok
16:17:06 <crc> foucist: I really don't do much scripting with retro; I'd build a custom image, and then write a shell script or use a modified vm to load it (this is what I do with the couple of small web apps I've written)
16:18:38 <foucist> crc: is that stuff you load into the image to turn off the interpreter's display of the code & 'ok' message?
16:18:52 <crc> that turns off the "Retro ...." banner and the "ok"
16:19:02 <crc> turning off code being evaluated is harder
16:22:52 <foucist> crc: btw, doing 'here ]' causes 11.0 to crash so i guess that's for 10.7 :P
16:22:52 <crc> you'd need to selectively disable and re-enable 'putc' for that
16:23:03 <crc> in 11.0, you'd use here ]]
16:23:13 <crc> since [ ] are redefined for use in creating quotes
16:23:13 <foucist> ah
16:23:21 <foucist> how do you handle cgi anyways?
16:23:33 <foucist> for web for example
16:23:45 <foucist> that's basically identical to shell scripting
16:23:47 <foucist> just need stdout
16:25:41 <crc> getEnv, and using casket:  http://rx-core.org/dev/casket.fossil/artifact?name=7fd1e6f7fbf2fce281ce95f33cd7722cbdcf3918
16:26:49 <crc> This is all still barebones; just adding what I need as I go along
16:28:38 <foucist> yeah
16:28:45 <foucist> you have too much fun with the barebones :P
16:29:15 <foucist> all the other projects built on top of retro get killed, the poor things :P
16:31:27 <foucist> crc: it seems rather strange to not have gone the regular stdout/shellscripting way of cgi, that would've been the easiest thing to handle?
16:31:48 <foucist> i vaguely recall doing a cgi script w/ retro or some forth ages ago..  
16:34:24 <foucist> crc: huh, how does casket output the html?  it looks like regualr stdout anyways?
16:34:32 <foucist> but you don't override putc in there
16:35:07 <crc> casket writes to stdout, but it's a custom image
16:35:18 <foucist> not in 10.7 ?
16:35:24 <foucist> i have it in the examples/ dir
16:35:25 <foucist> heh
16:35:42 <crc> it hooks itself to run when the image is loaded, and receives input from the cgi environment variables
16:37:37 <foucist> retro-10.7.6/retro --with retro-10.7.6/examples/casket.rx  not good enough?
16:37:39 <crc> http://sprunge.us/BieR is an example of a small thing using casket
16:38:00 <crc> it's running on my server as http://rx-core.org/dev/showPageViews
16:38:51 <crc> casket provides a framework. the app using it sets up a few paths/url variables, defines page handlers, and then hooks the casket "dispatch" as the "boot" function of the image
16:39:32 <foucist> is that code for 11 or 10.7?
16:39:38 <crc> 11
16:41:21 <crc> the 10.7.x implementation of casket has a couple of small differences (e.g., no Content-type: macro, requires s" for strings (no s" in retro11), and probably has a few other bits different
16:41:54 <foucist> crc: ok i'm trying that code you pasted plus the new casket.rx
16:42:05 <foucist> so i did ./retro --with yourpastie.rx
16:42:10 <foucist> it saves and goes bye
16:42:21 <foucist> and then i run ./retro again and no workie
16:42:26 <foucist> it doesn't run
16:42:27 <crc> any errors during the load?
16:42:37 <crc> ./retro --with .... | grep -v ok
16:43:16 <foucist> nope
16:43:24 <foucist> no errors
16:43:32 <foucist> well
16:43:37 <foucist> i didn't fix the paths
16:44:01 <crc> that wouldn't be too relevant if you're not worried about saving the image
16:44:12 <foucist> well the pastie includes the save
16:44:19 <foucist> so the image got saved (i used a copy )
16:45:02 <foucist> and then i run the image and it just quits w/o any display
16:46:35 <crc> PATH_INFO=/index ./retro
16:46:51 <foucist> ooh
16:47:06 <crc> set that CGI variable ;)
16:47:08 <foucist> :P
16:48:59 <foucist> crc: ok so why does casket successfully output text without showing it's code, can't i do the same thing using it in another retro script as a shell script?
16:49:09 <foucist> casket doesn't hack putc
16:49:18 <foucist> oh wait
16:49:19 <foucist> it does 
16:49:22 <crc> nothing reaches the listener
16:49:24 <foucist> the 10.7 one didn't
16:49:55 <crc> the casket dispatch is called on boot, then exits
16:50:01 <foucist> ah i see
16:50:46 <foucist> so just need a script dispatch
17:10:02 <crc> this is easy enough to do in retro 11:
17:10:02 <crc> : #!    ( ""- ) getToken getToken 2drop ;
17:10:02 <crc> : disp  (  q- ) &putc :devector do &drop &putc :is ;
17:10:02 <crc> [ [] &boot :is ] disp
17:10:02 <crc> [ [] &ok   :is ] disp
17:10:03 <crc> save bye
17:10:10 <crc> that'll give you an image with no output
17:10:25 <crc> anything that you want to show output gets put in a quote and passed to "disp":
17:10:42 <crc> words ( won't display )
17:10:42 <crc> [ words ] disp  ( will display the output only )
17:14:46 <foucist> ok
17:15:21 <crc> I'll throw this into the repo for 11.0 users (as library/script.rx)
17:15:36 <foucist> crc: is there something to produce a newline?
17:15:40 <foucist> since putn/puts etc don't have that
17:15:48 <foucist> and that code above doesn't produce any
17:15:56 <foucist> i guess you ahve a newline sequence in the ok definition
17:15:56 <crc> "\n" puts  or cr
17:16:01 <foucist> cr ok
17:16:41 <foucist> coolio
17:16:50 <foucist> crc: anyways, have you loaded ga144 simulator yet ? ;)
17:17:06 <crc> no; vmware crashed twice so far trying to install windows
17:17:13 <foucist> :(
17:17:15 <foucist> damn
17:17:37 <foucist> maybe try virtualbox then :P
17:17:39 <foucist> oh well..
17:19:53 <crc> I'll try that tomorrow
17:20:48 <foucist> cool
17:21:37 <crc> scripting language library module is at http://rx-core.org/rx.fossil/artifact?name=cdd14bb81ec3676cc99aff566ec761b87968a199
17:22:31 <foucist> crc: how's your mac mini holding out these days?
17:23:15 <foucist> i recently maximized the ram on this 3 year old macbook to 4 gigabytes (it can only actually handle 3.3 gb, but i figure dual channel and the slight extra would've been worth it..  cheap enough to get ram these days)
17:23:23 <foucist> and i also put in an SSD hdd, ocz vertex
17:23:29 <foucist> big difference
17:23:37 <foucist> s/big/huge
17:25:52 <foucist> the ram was like $40
17:26:00 <foucist> the hdd was 128gb, so like $220
17:26:13 <foucist> maybe ram was $80? i forget..
17:26:47 <foucist> i only went 128gb cuz my local store didn't have an ocz vertex 2 at 80gb 
17:28:35 <crc> I'll eventually up the ram in this mac mini
17:28:40 <crc> 1gb is no longer sufficient
17:29:35 <foucist> no sir..
17:29:38 <foucist> crc: how old is it
17:29:54 <crc> 2-3 years IIRC
17:30:29 <foucist> how big is the hdd?
17:30:35 <foucist> how much disk space do you need
17:30:36 <crc> 80gb
17:30:52 <foucist> you probably have external drives and such right?
17:31:07 <crc> I'm planning to setup 2tb external; I've got 320gb external currently
17:32:35 <foucist> could get a 60gb ssd for $130  http://www.newegg.com/Product/Product.aspx?Item=N82E16820227550&cm_re=vertex-_-20-227-550-_-Product
17:32:44 <foucist> 80GB for $170 
17:32:44 <foucist> http://www.newegg.com/Product/Product.aspx?Item=N82E16820227685&cm_re=vertex-_-20-227-685-_-Product
17:33:02 <foucist> hmm, 90 for $180  http://www.newegg.com/Product/Product.aspx?Item=N82E16820227601&cm_re=vertex-_-20-227-601-_-Product
17:34:25 <foucist> so something like 60gb sdd for $130  + say $40 for ram or so ?
17:34:31 <foucist> for less than $200 bam, super fast computer
17:34:36 <foucist> and you're getting an external hdd anyways
17:34:42 <foucist> so you probably don't need more htna 60gb ssd..
17:34:57 <foucist> SSDs are fast
17:35:12 <foucist> half the bootup time, programs load nearly instant now
17:35:41 <foucist> and beachballing times are negligable..  swap disk is fast
17:41:03 <foucist> crc: vertex 2 was the gold standard based on my research (i upgraded in december) so probably hasn't changed much since  intel's ssd came second
18:04:10 <crc> foucist: I'll add this to my wish-list for the upgrades later this year
18:10:05 <foucist> s/since  intel's/since. intel's/
20:35:41 <docl> https://github.com/libtom/libtomcrypt/blob/master/src/hashes/sha2/sha256.c
23:59:59 --- log: ended retro/11.02.27