Activity Graph

Page 1 of 26 | Next »


[00:50:35] gizmore: Quit: KVIrc 4.2.0 Equilibrium


[20:42:01] gizmore: has joined #ruby
[20:51:17] gizmore: just wanted to say good evening :) sorry


[01:08:56] gizmore: Quit: KVIrc 4.2.0 Equilibrium


[19:11:15] gizmore: has joined #ruby
[19:11:38] gizmore: typo... good evening :)
[19:12:53] gizmore: apeiros: i wanted to join php channel too
[19:12:58] gizmore: but confused syntax
[19:13:12] gizmore: i like php and ruby and c++ and js and java
[19:13:18] gizmore: and ObjectiveC
[19:14:02] gizmore: currently doing some php for a friend and at work
[19:14:48] gizmore: but ruby is so much more elegant you know
[19:15:00] gizmore: and the people here are more sane
[19:16:01] gizmore: php is not that bad... the performance of mod_php is quite nice on apache imho
[19:16:10] gizmore: and it has primitive type hinting \o/
[19:16:27] gizmore: i want to make a new game with ruby maybe
[19:16:58] gizmore: or learn python and make it with a friend.... or restart in C++.... or patch my PHP framework a lot.... or continue my ruby framework
[19:17:16] gizmore: either way.... i wanna code "GDO - Gizmore Data Objects"
[19:17:34] gizmore: yeah... php got quite good over the years.... there are still ugly quirks, but you know them
[19:17:43] gizmore: no... i didnt know of PDO when i did v1
[19:18:19] gizmore: GDO6(PHP) is way more sane and slim .... GDO6(Ruby) is also started, but currently on ice
[19:18:25] gizmore: GDO6(Ruby) is test driven
[19:18:48] gizmore:
[19:18:58] gizmore: ah this is php maybe -.-
[19:19:12] gizmore: (ruby port)
[19:19:48] gizmore:


[02:01:33] gizmore: Ping timeout: 264 seconds


[14:56:41] gizmore: has joined #ruby
[14:57:03] gizmore: havenwood: This is your daily appreciation message :) thx for your expertises and help
[15:39:33] gizmore: Quit: KVIrc 4.2.0 Equilibrium
[18:18:07] gizmore: has joined #ruby
[18:18:19] gizmore: >> puts.inspect
[18:29:59] gizmore: >> Object.class_methods
[18:30:10] gizmore: >>
[18:30:23] gizmore: >>
[18:30:38] gizmore: is this ruby?
[18:30:54] gizmore: >> Object.instance_methods
[18:38:16] gizmore: havenwood: you around?
[18:41:04] gizmore: still working on GDO(Ruby)
[18:41:12] gizmore: let me push latest stuff
[18:41:57] gizmore: $ git commit -am "1.00r1 havenwood"
[18:42:12] gizmore: havenwood is codename for GDO(Ruby) 1.00
[18:42:32] gizmore: i ditched your versioning suggestions
[18:42:44] gizmore: i stuck to mine (1.00, 1.01 etc
[18:43:11] gizmore: i usually put desrc (thx username)
[18:43:27] gizmore: GDO(Ruby) 1.00 - havenwood
[18:44:15] gizmore: in GDO(PHP) i got a "" which does find -exec git stuff
[18:44:27] gizmore: it pushes all my modules with same commit msg
[18:44:38] gizmore: i am only 1 man
[18:44:52] gizmore: GDO is modular
[18:46:03] gizmore: let us do a kickstarter where we do a havenwood hero movie, yeah
[18:47:25] gizmore: >>
[18:48:14] gizmore: >> apeiros
[18:48:20] gizmore: >> :apeiros
[18:49:11] gizmore: >> class Object; alias :new :old; end
[18:49:29] gizmore: >> class Object; def old; new; end; alias :new :old; end
[18:49:56] gizmore: i expected a deadloop Oo
[18:52:28] gizmore: I am working on an own framework
[18:53:08] gizmore: it will support: "HTTP,Websocket,ICQ,Jabber,XMPP,CGI,Shell,Netcat,Gopher"
[18:53:28] gizmore: cache invalidation is a thing i got right
[18:54:16] gizmore: gdo Register Form gizmore password 1 submit
[18:54:49] gizmore: apeiros: ^ this is current bash syntax to trigger registration of user account via bash
[18:57:00] gizmore: `gdo Register Form gizmore password 1 submit` <-- this is CLI to create an account with my "framework"
[18:57:59] gizmore: i have not coded that far yet.... but plan is one framework serves all
[19:00:20] gizmore: waited for you and went quiet until you were back, master apeiros
[19:00:58] gizmore: git commit -am "1.00-havenwood-r1"
[19:01:09] gizmore: wrong window ;)
[19:03:21] gizmore: (roast my tests)
[19:06:37] gizmore: apeiros: (roast my unit tests for my signup module)
[19:07:00] gizmore: the same code should work for websocket etc
[19:11:54] gizmore: This is a model for signup IP recording/restriction
[19:11:58] gizmore:
[19:13:00] gizmore: GDO signup is quite nice..... emails or username is only burned when you activated
[19:13:13] gizmore: this is the activation token table:
[19:13:29] gizmore:
[19:14:19] gizmore: already registered with nickname/email
[19:14:24] gizmore: burned mail
[19:14:30] gizmore: many signups bv
[19:14:39] gizmore: many signups burn mail before activation
[19:17:47] gizmore: apeiros: GDO does not feature bind variables or prepared statements
[19:17:57] gizmore: it is my own DBA
[19:18:09] gizmore: i dislike ActiveRecord
[19:18:32] gizmore: GDO only works with mysql
[19:18:55] gizmore: by design :)
[19:20:59] gizmore: ActiveRecord is the inner join of some DBA
[19:21:26] gizmore: GDO might use advanced mysql features instead
[19:21:44] gizmore: like different storage engines
[19:24:33] gizmore: another example
[19:24:47] gizmore: table.delete_where("user_name=#{activation.quoted(:user_name)} OR user_email=#{activation.quoted(:user_email)}")
[19:25:31] gizmore: this actually loads every entitiy to delete and calls the events
[19:25:39] gizmore: unlike ActiveRecord
[19:26:20] gizmore: GDO support combined primary keys, unlike ActiveRecord
[19:26:38] gizmore: GDO features a single identity cache (unique feature)
[19:27:58] gizmore: single identiy cache means every object retrieved from db is filtered through cache, and will return the same instance when the same row is queried multiple times
[19:28:40] gizmore: currently this is disabled in GDO(Ruby) but i got great results in PHP
[19:29:07] gizmore: GDO is not designed to be scalable atm
[19:39:53] gizmore: rootd00d: you need to lock access on writes and reads maybe
[19:39:59] gizmore: threading is not too hard
[19:40:29] gizmore: you just need to choreograph your code that accesses shared data
[19:40:37] gizmore: semaphoes, locks, whatever
[19:40:41] gizmore: lockspins!
[19:40:48] gizmore: semaphores, locks, whatever *
[19:41:16] gizmore: i am not into that Concurrent lib
[19:41:22] gizmore: i use only Thread.current
[19:41:59] gizmore: rootd00d: on just wrap a lock around accessing your shared data could work
[19:43:27] gizmore: dr3w_: tricky
[19:44:14] gizmore: dr3w_: match <script>.*</script> or .*
[19:44:45] gizmore: rootd00d: good luck with your threading exe
[19:44:50] gizmore: rootd00d: good luck with your threading experience *
[19:46:29] gizmore: dr3w_: maybe match scripts and afterwards split by that
[19:46:41] gizmore: like first (<script>.*</script>)
[19:46:48] gizmore: then split by (<script>.*</script>)
[19:47:00] gizmore: just some ideas for your horrible idea
[19:47:51] gizmore: rootd00d: i have zero experience with ThreadPool
[20:14:12] gizmore: >> 1.00.major
[20:14:18] gizmore: >> "1.00".major


[01:04:54] gizmore: Ping timeout: 260 seconds
[16:52:08] gizmore: has joined #ruby
[16:54:00] gizmore: << puts "havenwood: you are the best ruby supporter i ever encountered"
[16:54:12] gizmore: >> puts "really"
[16:56:45] gizmore: havenwood: (comments welcome, also from others)
[21:20:54] gizmore: >> lat, lng = "1,2".split(',').map{|v|v.to_f}
[21:21:21] gizmore: leitz: glob for what exactly?
[21:23:28] gizmore: globbed in gemspec?
[21:24:33] gizmore: make one main (gdo) and have module method as param
[21:24:54] gizmore: like gdo Register Form --help
[21:25:08] gizmore: yeah globs should be fine
[21:25:18] gizmore: as long as you dont use it on a firefox sourcecode
[22:02:58] gizmore: can i measure the clock ticks wasted in code?
[23:26:06] gizmore: Read error: Connection reset by peer


[23:00:57] gizmore: has joined #ruby


[12:56:19] gizmore: has joined #ruby
[16:15:50] gizmore: Read error: Connection reset by peer


[01:14:44] gizmore: Ping timeout: 256 seconds


[01:12:01] gizmore: has joined #ruby
[05:26:48] gizmore: Quit: KVIrc 5.0.0 Aria
[15:14:00] gizmore: has joined #ruby
[15:47:44] gizmore: like
[15:47:58] gizmore: KaffeeJunky123: modifieng and returning eh?
[15:49:17] gizmore: KaffeeJunky123: in my project i chose _foo for getters and foo(foo); self; for setters (chain)
[15:52:33] gizmore: i did a major design pattern on my project
[15:52:41] gizmore: _foo (getters)
[15:52:48] gizmore: foo(foo) setters
[15:53:15] gizmore: _foo (being public getters)
[16:03:36] gizmore: Zarthus: good question
[16:03:48] gizmore: i dont like this decorator
[16:04:33] gizmore: why deal with those internals of attr_* when you can just define your own to be sure


[01:16:49] gizmore: Ping timeout: 248 seconds


[01:16:57] gizmore: Ping timeout: 240 seconds
[06:34:25] gizmore: i wonder if havenwood is awake
[06:37:09] gizmore: havenwood: (wrote my own session manager with rack)
[07:11:01] gizmore: myndzi: only hint i can give is that Thread.current[hash] can be used to store thread specific data
[07:11:20] gizmore: like Thread.current[:gizmore_foo] =
[07:11:43] gizmore: for thread variables
[07:51:13] gizmore: I wonder what nickname Matz would choose
[10:45:42] gizmore: i wrote an own event lib with docs in 70 lines Oo


[01:19:05] gizmore: Ping timeout: 240 seconds
[14:36:21] gizmore: is it legal to put #@license <LIC> at the header of each file and protect some classes with an individual license?
[14:36:47] gizmore: also this channel does not force ssl... i am going to sue myself
[14:41:20] gizmore: i am going to patch random by inserting random \x00 to enhance entropy count
[16:09:15] gizmore: miah: thank you very much
[16:09:24] gizmore: license tooling ft
[16:10:54] gizmore: ( Omnia – Earth Warrior )


[01:16:35] gizmore: has joined #ruby
[14:57:52] gizmore: what would be a reason to use Marshal over JSON in a session table data column?
[14:58:29] gizmore: i am thinking of using JSON because it might be faster.... maybe i should benchmark and choose the faster impl?
[14:58:41] gizmore: input is trusted, so marshal would offer better features
[15:03:45] gizmore: havenwood: thanks. will take a look
[15:05:44] gizmore: havenwood: i will add msgback support and probably use it for session data. for more complex serialization i will use Marshall. JSON is already available as datatype in my framework :)
[15:07:21] gizmore: croberts: the Hash class does not have a name method... you probably need something like
[15:07:33] gizmore: >> {a:1}.first
[15:07:39] gizmore: >> {a:1}.first
[15:07:45] gizmore: << {a:1}.first
[15:08:57] gizmore: first is a horrible idea though..... just compare against the name somehow


[01:21:07] gizmore: Ping timeout: 256 seconds


[14:59:04] gizmore: has joined #ruby


[01:18:59] gizmore: has joined #ruby
[19:15:18] gizmore: cthu|: should work
[20:06:06] gizmore: Read error: Connection reset by peer


[01:24:21] gizmore: Ping timeout: 264 seconds


[01:25:07] gizmore: Ping timeout: 256 seconds
[17:58:06] gizmore: usuario: holas
[18:07:16] gizmore: havenwood: my framework will be based on rack in terms of request / response. means that even cli and chat bindings will use http response codes and somehow cookies will work
[18:07:29] gizmore: i bet this is a bad idea
[18:10:58] gizmore: Mike11: a ruby application framework. it shall cover httpd,chat,cli,exe,websocket,and more?
[18:11:13] gizmore: you write one method for all bindings
[18:11:19] gizmore: a method has params
[18:11:23] gizmore: and returns a response
[18:11:35] gizmore: all vartypes extend GDT (own datatype)
[18:11:49] gizmore: we will see
[18:12:10] gizmore: yes. but how nice will it be
[18:12:38] gizmore: (PHP) (Ruby)
[18:12:58] gizmore: the PHP has websocket and http more or less working nicely
[18:13:08] gizmore: the Ruby is 2-4 weeks old
[18:13:17] gizmore: but Ruby is test driven!
[18:13:24] gizmore: the PHP is hax
[18:13:40] gizmore: i still say my gdo6(PHP) is better than laravel in some terms
[20:08:56] gizmore: >> class ::Object; def to_s;to_s;end;end
[20:39:16] gizmore: apeiros: i expected to cause some exception
[20:39:45] gizmore: apeiros: thx for all your support here over the years
[20:40:11] gizmore: apeiros: you are just 2 points away from havenwood
[20:41:02] gizmore:
[20:42:00] gizmore: apeiros: of course i value friendships by probable outcome. (see GDO::Base)
[20:42:23] gizmore: this is not ruby-talk
[20:43:57] gizmore: als deutscher darfst du nicht stolz auf dein land sein
[20:44:32] gizmore: als deutscher darfst du nicht stolz auf dein land sein
[20:44:42] gizmore: darfste nicht
[20:47:37] gizmore: >>class Object; def to_s; "a"; end; end;
[20:48:24] gizmore: >>['a'].select{|b}
[20:51:02] gizmore: >>['a'].select{|b| b}
[20:53:52] gizmore:


[21:36:57] gizmore: we are going to get a JIT soon :)
[21:37:47] gizmore: jmaister: if you compare GDO6(PHP) and GDO(Ruby) you will notice that it's a completely
[21:37:57] gizmore: in PHP you get a new process on every request
[21:38:11] gizmore: in RubyPassenger your process lives forever
[21:41:31] gizmore: (sry=
[22:09:17] gizmore: mkroman: look for http2 clients
[22:09:28] gizmore: if there is none, maybe write one
[22:19:43] gizmore: mkroman: when in doubt use `curl`
[22:20:09] gizmore: i heard windows can use curl too when the admin is cool
[22:21:03] gizmore: >>`curl localhost`
[22:21:13] gizmore: >>`ls -asl`
[22:22:27] gizmore: >>class Object; def self.included(base); puts base; end; end
[22:26:23] gizmore: apeiros: as if a mortal could break it
[22:39:47] gizmore: Emerald: use GCC to compile it
[22:40:23] gizmore: usually "make" and ./configure
[22:40:29] gizmore: usually ./configure and make
[22:40:41] gizmore: for C projects
[22:40:50] gizmore: then i am out
[23:20:44] gizmore: <%='erb' + 'is fun'%>
[23:21:08] gizmore: wrote own template engine
[23:22:02] gizmore: havenwood: own template engine: