BiDOrD_ has quit [Read error: Connection reset by peer]
cago1 has joined #ocaml
andreypopp has joined #ocaml
Cyanure has joined #ocaml
mcclurmc_away is now known as mcclurmc
fusillia has quit [Read error: Connection reset by peer]
Neros has quit [Ping timeout: 265 seconds]
thomasga has quit [Read error: No route to host]
thomasga has joined #ocaml
ontologiae has joined #ocaml
testcocoon has quit [Quit: Coyote finally caught me]
Kakadu has joined #ocaml
testcocoon has joined #ocaml
Neros has joined #ocaml
Neros has quit [Ping timeout: 260 seconds]
avsm has joined #ocaml
gustav__ has joined #ocaml
_andre has joined #ocaml
<gustav__>
Hi, is there an _easy_ way to replace a string of the form "$xyz" from another string "hello $xyz, welcome!" and substitute with "joe?" WITHOUT using Str? I can't get it to work.
<companion_cube>
why would you want not to use Str? ôO
<gustav__>
I don't like the name but I could try to load it...
<flux>
..you're not using Str because of its name?-)
<flux>
but actually, Str isn't that great a library if you ever intend to use threads
chambart has joined #ocaml
<gustav__>
No. I had that feeling.
<flux>
I think there are these options: 1) use Str 2) use some other templating library for ocaml 3) use pcre 4) do it manually :)
<gustav__>
Hmm.
<gustav__>
Maybe if I can convert the string to a list.
<gustav__>
I don't get why all languages make such a difference between the two.
<flux>
Haskell doesn't
<gustav__>
Except maybe C.
<gustav__>
Okay.
<flux>
but I think its String (a list of characters) doesn't perform that well in real-life, so people use Text nowadays
<gustav__>
I haven't tried Haskell.
<flux>
it's just not very efficient to store strings as linked lists: very small items, very long lists
<gustav__>
Yeah. Usually that's the problem with these neat...constructions. Poorly optimized.
<gustav__>
True.
<gustav__>
But they don't have to be stored like that, just because the language is like that.
<flux>
but the other thing is that ocaml doesn't do run-time type information
<flux>
so it would probably result in a wart when dealing with polymorphic values
<Kakadu>
gustav__: I can always write an OCaml module which will incapsulate string and store it as you want :)
<flux>
but that being said, there is a regular expression pattern matching language extension for ocaml
<Kakadu>
s/I/you/
Yoric has quit [Ping timeout: 246 seconds]
<flux>
:-)
* Kakadu
aslways make stupid mistakes
<gustav__>
You do that. ;-)
<flux>
wish there were a bunch of people doing that
<Kakadu>
one more: always*
<gustav__>
Yeah.
<flux>
"I have this problem when doing X" "no worries, I'll write it for you"
<gustav__>
People just doing what you want.
<gustav__>
erhmerhgerd
<flux>
exactly!
<flux>
actually I've thought about something that would be integrated into an editor
<gustav__>
Line 11 is the last line in the example.
caligula__ has joined #ocaml
<gustav__>
There's a new line above the first line after --begin in the pastebin I did.
zzz_` has joined #ocaml
caligula_ has quit [Read error: Connection reset by peer]
zzz_ has quit [Remote host closed the connection]
Haseo has quit [Ping timeout: 265 seconds]
Haseo has joined #ocaml
<flux>
gustav__, have you looked what the type of Printf.printf is?
<gustav__>
No. But. I want process to return a string. I thought it did.
<gustav__>
But I will.
<flux>
and it does
<flux>
but the problem is that string variables are not format strings
<gustav__>
Oh.
<flux>
format strings are staticalyl checked at compile time
<gustav__>
Aha.
<flux>
so you can see it cannot work with dynamic strings
<flux>
you can do this: printf "%s" (process "hello")
<gustav__>
I shouldn't send that stuff to printf anyway.
<gustav__>
Yeah.
<gustav__>
Right. Now the "" gets an oob exception... hmm.
<flux>
also, there's another problem in your process-function. the r string is empty. and its change cannot be changed. better use String.create (String.length x) instead
<flux>
and there's a third problem
<gustav__>
I tried that, but I don't get a string back. I get some function.
<flux>
the for-loop goes one character too far
<flux>
you probably used String.make instead?
<flux>
String.make makes an n-length strings filled with a character
<flux>
String.create is more like.. C malloc :)
<gustav__>
Ah. D'oh.
<flux>
if you get a function when expecting a value, it almost certainly means you have given too few arguments
<flux>
(due to partial evaluation)
<gustav__>
Hmm.
<gustav__>
I haven't seen anyone else use partial evaluation before. xD
<gustav__>
OH. Now it works. Awesome.
<gustav__>
Hmm.
<gustav__>
I mean, it worked all the time. Maybe I was talking about my brain. :-P
lolcathost has quit [Quit: leaving]
Yoric has joined #ocaml
<gustav__>
Some ask page suggested to use Buffer instead of String for these kinds of things, is that correct you think? It sounds snappier.
<gustav__>
It has nice functions, too. add_char, for instance.
<flux>
I don't know about snappy
<flux>
but it's more suitable for buildling strings
<gustav__>
Ah.
<gustav__>
I want that.
<gustav__>
Yeah. Those error messages are helping me.
<gustav__>
C sends you out in space.
<gustav__>
"Uncalibrated molecule at 0x3f4f43"
<gustav__>
Damn physisists.
<gustav__>
Can't even spell it.
lolcathost has joined #ocaml
<pippijn>
%%% lexing with re2ml took 0.538540s
<pippijn>
%%% lexing with ocamllex took 1.049168s
<pippijn>
%%% lexing with flex (C++) took 0.421299s
chambart has quit [Ping timeout: 246 seconds]
Neros has joined #ocaml
BiDOrD_ has joined #ocaml
BiDOrD has quit [Ping timeout: 246 seconds]
beckerb has joined #ocaml
sepp2k has joined #ocaml
avsm has quit [Quit: Leaving.]
<Kakadu>
pippijn: So, You've succeded to find a test where your lexer is faster?
<Kakadu>
:)
Neros has quit [Ping timeout: 260 seconds]
<pippijn>
Kakadu: it's always faster
<Kakadu>
pippijn: It was trolling
<djcoin>
:)
cdidd has joined #ocaml
<pippijn>
if it knows it's operating on string buffers, it can be faster: %%% lexing with re2ml took 0.406631s
Neros has joined #ocaml
xavierm02 has joined #ocaml
<pippijn>
Kakadu: there is a perl module that parses JSON
<pippijn>
it parses this 43MB file in 1.6 seconds and also builds a perl data structure out of it
<pippijn>
my JSON parser takes 0.9 seconds just for lexing and parsing, not even building a data structure
<pippijn>
not even parsing strings
<pippijn>
sad..
<Kakadu>
TT
<pippijn>
%%% lexing with re2ml took 2.663109s
<pippijn>
this is with parsing strings and integers
avsm has joined #ocaml
<pippijn>
=> ocaml is a lot slower than perl
<pippijn>
or well.. *my* ocaml code is slow
<flux>
I've found a similar performance mismatch when doing log analysis
<flux>
perl just is damn fast for practical extraction and reporting :)
<pippijn>
this is without parsing strings, just returning them in tokens: %%% lexing with re2ml took 0.820383s
<pippijn>
so my string "unescape" is slow
<pippijn>
I already knew that, though
<pippijn>
unescape builds a list, first
<flux>
I once tried to compete with mutt on reading&threading a mailbox. failed :(
<flux>
but mutt is pretty fast
pcjoby has joined #ocaml
ppseafield has joined #ocaml
avsm has quit [Ping timeout: 268 seconds]
<pippijn>
slightly improved unescape: %%% lexing with re2ml took 2.062630s
<pippijn>
still super slow
<pippijn>
one copy less: %%% lexing with re2ml took 1.973362s
answer_42 has joined #ocaml
ocp has joined #ocaml
<pippijn>
integers instead of a variant: %%% lexing with re2ml took 1.917814s
ftrvxmtrx has joined #ocaml
<pippijn>
not worth it
<flux>
how about adding multi process support?-)
<flux>
you would split the data in half, lex them separately.. and then be extra smart about the boundary :)
<djcoin>
I guess your parser already works with streams ?
<pippijn>
djcoin: yes
Kakadu has quit [Remote host closed the connection]
Kakadu has joined #ocaml
sgnb has joined #ocaml
avsm has joined #ocaml
avsm has quit [Ping timeout: 245 seconds]
<pippijn>
%%% lexing with re2ml took 1.183573s
<pippijn>
flux: not multi-process, but I moved unescape into the lexer itself
ankit9 has quit [Quit: Leaving]
avsm has joined #ocaml
justdit has quit [Ping timeout: 248 seconds]
avsm has quit [Quit: Leaving.]
mjonsson has joined #ocaml
avsm has joined #ocaml
gnuvince has quit [Ping timeout: 252 seconds]
Neros has quit [Read error: Connection reset by peer]
Neros has joined #ocaml
avsm has quit [Quit: Leaving.]
justdit has joined #ocaml
BiDOrD_ has quit [Ping timeout: 260 seconds]
avsm has joined #ocaml
smondet has joined #ocaml
mjonsson has quit [Ping timeout: 240 seconds]
gnuvince has joined #ocaml
Neros has quit [Read error: Connection reset by peer]
BiDOrD has joined #ocaml
lolcathost has quit [Ping timeout: 256 seconds]
Neros has joined #ocaml
Kakadu has quit [Quit: Konversation terminated!]
gnuvince has quit [Ping timeout: 265 seconds]
answer_42 has quit [Ping timeout: 276 seconds]
answer_42 has joined #ocaml
andreypopp has quit [Quit: sleep]
travisbrady has joined #ocaml
<thelema>
pippijn: there's a time difference between using integers and using a variant type?
<pippijn>
thelema: type t = NoEscape | Escape | HexEscape of int
<pippijn>
thelema: vs. -1 | -2 | +n
<thelema>
pippijn: ah, yes. a tiny difference; the N would be boxed
<pippijn>
yes
<thelema>
I once wrote code that re-implemented an option type unboxed, using NULL for None. I don't recall it having much of a speed difference
<pippijn>
thelema: I did that in one program and it helped a *lot*
<thelema>
I guess it depends on your app
<pippijn>
yes
gnuvince has joined #ocaml
Submarine has joined #ocaml
Submarine has quit [Changing host]
Submarine has joined #ocaml
Kakadu has joined #ocaml
jamii has joined #ocaml
Neros has quit [Quit: No Ping reply in 180 seconds.]
Neros has joined #ocaml
hkBst has quit [Quit: Konversation terminated!]
BiDOrD has quit [Read error: Connection reset by peer]
<Pantoufle>
gustav__: try to put the (); at the end of line 13
<gustav__>
Negative.
<Qrntz>
gustav__, variable names start with a lowercase letter
<gustav__>
There is something "up" with the "and."
<Qrntz>
and that too, in fact
<Qrntz>
use &&
<gustav__>
Qrntz: Yes?
<Qrntz>
«and» is reserved to definitions
<gustav__>
Ah. Naow.
<gustav__>
I see.
<Qrntz>
&& and & are logical AND operators, but the latter is deprecated
<Qrntz>
ach, never mind my statement about variable names, I parsed your code the wrong way
<gustav__>
So I can't use "not" then, either?
<gustav__>
Hum...
<gustav__>
Or can I?
Neros has quit [Ping timeout: 260 seconds]
answer_42 has joined #ocaml
<gustav__>
Yay. Progress...
<gustav__>
WEowoeowow!
<Qrntz>
gustav__, you can, «not» is actually an unary boolean operator
<gustav__>
Can I put a 'type' in a let x = z? I won't be using it anywhere else. Well, like in the script.
<gustav__>
Do I have to create a module for that?
<gustav__>
The /thing/ isn't exactly agreeing with me.
iago has joined #ocaml
<Qrntz>
gustav__, so you want a local type?
<gustav__>
Yes.
sgnb has quit [Ping timeout: 246 seconds]
<_habnabit>
type x = z
<gustav__>
And also, why can't I have multiple statements in an if statement? o_o
<gustav__>
_habnabit: It complains about that.
<_habnabit>
gustav__, just use parentheses or begin/end if you want to execute multiple imperative statements in an if
<_habnabit>
gustav__, 'it complains' also isn't an error message
<gustav__>
_habnabit: "Syntax error."
<_habnabit>
gustav__, when you type what, exactly?
<gustav__>
let process x = \n type scanning = InA | InB
<gustav__>
SE is the second line.
<_habnabit>
you can just move that type out to the module scope
<gustav__>
But then it isn't local. :/
<gustav__>
I'm not in a module scope.
<gustav__>
I think.
<gustav__>
Just a plain old file.
<Qrntz>
every file is a module
<_habnabit>
yes, files are modules
<gustav__>
Okay.
tac has joined #ocaml
<_habnabit>
type scanning = InA | InB let process x = ...
<gustav__>
Yes, that's what it is now.
iago has quit [Quit: Leaving]
<gustav__>
I guess it doesn't matter.
<_habnabit>
you don't have to include that type in your .mli file, so nobody will know about it
<thelema>
no local types, they have to be declared as a phrase
<thelema>
private types are all you get.
<gustav__>
What about the suspicious types...?
sgnb has joined #ocaml
<thelema>
suspicious types?
<thelema>
I see you parsing an input string x, which is pairs of alphabet strings (variable name) followed by arbitrary data (rest), separated by $
<thelema>
if I were doing this, I might use mutually recursive functions:
<thelema>
let process x = let len = String.length x in let r = Buffer.create 100 in let rec rest i = if i < len then match x.[i] with '$' -> var (i+1) | c -> Buffer.add_char r c; rest (i+1) and var i = if i < len then match x.[i] with a..zA..Z -> var (i+1) | _ -> rest i in rest 0; Buffer.contents r
<thelema>
Without formatting, it looks pretty terrible.
<gustav__>
I want to use something neat like a :: rest... if a = "$" ...something like that. But it's hard to do with substrings.
<gustav__>
I can't even explain it...
<gustav__>
I guess there are no operators for chars, so.
<gustav__>
My code is an iterative version of a recursive function, let's say...
<thelema>
using the command right after the source?
<gustav__>
That works. o_O
<thelema>
gustav__: very odd..
<thelema>
multiple ocaml installations?
mfp has quit [Read error: Connection reset by peer]
<gustav__>
No idea.
<thelema>
have you ever installed ocaml or any libraries except through ubuntu packages?
<gustav__>
No.
<thelema>
ok, then probably not.
<gustav__>
There's only one {ocaml,ocamlfind.}
<gustav__>
On the system.
<thelema>
good.
<thelema>
why are you recompiling your library every second?
<gustav__>
I have to listen to some Snoop Dogg, this stuff pisses me off.
<thelema>
I look at the perl invocation, and it does a full recompile every second.
<thelema>
probably not the problem...
<gustav__>
thelema: Well, I usually type in the compile stuff after I edit my sources, but that's annoying.
<thelema>
ok, I assume you won't leave that running in production...
<gustav__>
There is no production for this. And no, not on the production machine at least, I guess.
<thelema>
could you try just running the first command by itself
<thelema>
without the perl wrapper?
avsm has joined #ocaml
<gustav__>
Eh.
<gustav__>
Right. I didn't restart the wrapper. >_<
<gustav__>
There we go.
* gustav__
hears *facedesks* from a distance.
<gustav__>
:D
<thelema>
yes, very loud
<gustav__>
xD
<gustav__>
Can even be heard thru void space.
<gustav__>
It complains about match not being exhaustive for a string match. But how can I be exhaustive? There is an infinite amount of possible matches...?
<gustav__>
Hmm.
<gustav__>
I must not be getting it.
<thelema>
use "| _ -> " as default case
<Qrntz>
add a catch-all
<thelema>
or "| s -> " if you care what the string is
<gustav__>
Right.
<gustav__>
I wonder if something is, somewhere, trying to fulfill the wishes of this exhaustion.
<gustav__>
Business Intelligence and Bayseian inference are almost the same thing, it seems, anyway. But I was referring to the former.
<gustav__>
Idk.
<gustav__>
No...well, in some abstract way, maybe...
<gustav__>
thelema: gnuplot can adapt functions to data, or what you say, that's the most important.
<gustav__>
So you can get like: It's 51 minutes left til gustav__ has written more than thelema in #ocaml.
<thelema>
? you mean fitting functions?
<gustav__>
Yes, exactly.
<thelema>
linear regression isn't particularly difficult.
<gustav__>
I haven't tried it myself.
<gustav__>
First I need some data.
<gustav__>
Hmmmm.
<gustav__>
Some RSS feed maybe.
lolcathost has joined #ocaml
<gustav__>
Having a bunch of sensors at home would be cool.
<gustav__>
Or in a tree down town.
<gustav__>
:P
avsm has joined #ocaml
lolcathost has quit [Read error: Connection reset by peer]
Skolem has joined #ocaml
avsm has quit [Quit: Leaving.]
Yoric has joined #ocaml
<gustav__>
Yeah, Bayesiean inference sounds similar to what business intelligence is. It's probably useful, any way.
<gustav__>
I don't work with any of these things though.
<gustav__>
Just a hobby.
<gustav__>
Business Intelligence is a buzzword, I think...
<gustav__>
It's in IDG, then it's a buzzword. <- More business intelligence. :)
tac is now known as tac-nap
emmanuelux has joined #ocaml
beckerb has quit [Quit: Konversation terminated!]
lolcathost has joined #ocaml
lolcathost has quit [Client Quit]
<gustav__>
Who maintains Batteries? How is that done?
<ppseafield>
How does ocaml implement comparison operators?
<flux>
primitively
<flux>
basically they are compared by their runtime reprepsentation
<ppseafield>
Ah, so there's magic behind the scenes that figures out what strongly-typed comparison to use?
<pippijn>
ppseafield: no
Xizor has joined #ocaml
<pippijn>
the type system guarantees that the types are compatible
<pippijn>
at runtime, it just traverses the object graph and compares integers and strings (and custom blocks with a custom comparator)
<ppseafield>
pippijn: so I can write my own (<) for my own types?
<pippijn>
the comparison operator doesn't know whether it is comparing an array or a tuple or a record
<pippijn>
ppseafield: the polymorphic (<) does not use your (<)
<pippijn>
because it has no type information
<ppseafield>
so I *can't* write my own (<), at least not with that name?
<pippijn>
you can write your own (<) with that name
<pippijn>
it will hide the one from Pervasives
larhat has joined #ocaml
<pippijn>
you can implement your own polymorphic (<), too
<pippijn>
but only using unsafe interfaces
<ppseafield>
pippijn: you mean do something special for my own type, and then default to the Pervasives one?
<pippijn>
ok
<pippijn>
try it :)
<pippijn>
you can build anything
gnuvince has quit [Ping timeout: 252 seconds]
ontologiae has joined #ocaml
<pippijn>
ppseafield: what would the type of that (<) be?
<ppseafield>
I'm trying to understand if the Pervasives (>) etc. could be overloaded essentially
<pippijn>
overloaded
<ppseafield>
since it already seems to be overloaded for ints, floats, etc.
<pippijn>
no, it's not overloaded
<pippijn>
do you know the function "memcmp"?
<ppseafield>
I don't
<pippijn>
ok
<pippijn>
Pervasives.(<) just compares bytes, basically
<pippijn>
it doesn't know anything about the meaning (or type) of what it is comparing
<ppseafield>
oh... thanks, that's what I was looking for
<pippijn>
but you want this to solve a certain problem
<pippijn>
what is that problem?
<gustav__>
I think I know the answer.
<gustav__>
42.
<pippijn>
gustav__: do you know the question?
<gustav__>
pippijn: Yes.
<ppseafield>
I was just curious how the 'a -> 'a -> bool function returned correct results without knowing type information
<pippijn>
ppseafield: ok
<pippijn>
now you know
<ppseafield>
pippijn: so now by extension, does the order of possible constructors for a type effects the results of its comparisons?
<pippijn>
yes
<thelema>
ppseafield: to understand the builtin polymorphic compare works, you have to understand how values are represented in memory
<thelema>
because it's these that are compared
<ppseafield>
and each new possible constructor for a type gets an incrementing value "tag", i take it?
<thelema>
pippijn: the builtin compare is a bit better than just comparing bytes; it's able to recurse through the structure of compound objects
<pippijn>
thelema: I said that, but he didn't understand, so I simplified
<thelema>
ppseafield: mostly; a constructor that takes arguments can have the same tag as constructor that doesn't
<thelema>
pippijn: oops, I didn't read far enough back. sorry
<ppseafield>
and since I see that (5, 3) > (5, 4) is false, is this a left-to-right comparison traversal?
<gustav__>
I've got a bit on my screen.
<thelema>
ppseafield: yes, mostly.
<ppseafield>
pippijn, thelema: thanks for your explanations!
lolcathost has joined #ocaml
<thelema>
ppseafield: you're welcome
<gustav__>
Thanks everyone who's been talking to me, too. I don't know how to repay you. I'd like to be active in some project but I haven't really found a reeeally interesting one and I usually don't finish things. xD
<gustav__>
Trying to push forward with my BI Application.
<thelema>
:) welcome to #ocaml
<gustav__>
:)
Associat0r has joined #ocaml
<thelema>
write a blog post about your experiences with ocaml, or a mini-tutorial for doing some of what you're doing. That will more than repay our help
<gustav__>
libapache2-mod-ocamlnet on Ubuntu could need some things done to it. It's not as updated as mod-php5, i.e. it doesn't work out of the box. But I don't know the objective of these packages, maybe you don't want to work like PHP.
<thelema>
gustav__: we probably don't want ocaml to work like php
<gustav__>
Okay. I'll try... hmm. Yeah, have to get a site first.
<gustav__>
thelema: No, that's what I'm thinking.
<gustav__>
The package is by no means broken, it took some tinkering to get it working, though. Maybe I could write that tutorial. Or a general overview...
<thelema>
Any of that would help
<gustav__>
I wanna try out camlbox. That stuff is neat.
<thelema>
and it's really easy to set up a blog or other website
<gustav__>
Yes, but I want a VPS... I think. I've been wanting to for many years.
<gustav__>
I could bring out an old 800MHz Pentium 3 from the closet and run it on that. Thing is I only have ADSL right now. Bummerrr.
<gustav__>
I think I'll be getting fiber. At home. Soon.
<thelema>
I'd recommend something like weebly to start.
<thelema>
or just use a github account and their markup.
<thelema>
if you're feeling tech-macho
<gustav__>
Yeah, right. I probably am. But I
<gustav__>
'll try Weebly.
<gustav__>
I just want it minimal.
<gustav__>
Weebly doesn't sound very serious...
<gustav__>
x.weebly.com...
<pippijn>
I have a question related to Lwt
<gustav__>
I have to pay to remove their logo. :@
<pippijn>
I have a program with two input sources: a network connection and a user
<pippijn>
both operate on the same data
<pippijn>
at the moment, it's like this: most of the time the server sends things and the client displays what the server sends
<gustav__>
Have you tried hitting the user in the head?
<pippijn>
but sometimes, the server asks the user something, so then I need to read user input
<pippijn>
while asking the user, the server still keeps on sending things that the client needs to display
<pippijn>
at the moment, asking the user blocks the whole process
<pippijn>
how can I let these two things run concurrently?
<gustav__>
Threads?
<pippijn>
actually, I have an idea now
<diml>
pippijn: how do you ask the user ?
<pippijn>
diml: read_line stdin
<pippijn>
I need to put user interaction into a separate thread
<thelema>
pippijn: is there an lwt-enabled read_line?
<pippijn>
yes
<pippijn>
I'm using it
<diml>
it shouldn't block...
<pippijn>
it blocks because I coded it that way
<diml>
ok
<thelema>
pippijn: umm, then code it so it doesn't block?
<pippijn>
thelema: the user input needs to modify data
<pippijn>
and that data is constantly being modified by the network input, as well
<thelema>
so it can do that when the line is read in...
<thelema>
ah, sounds like you need the guarantees that async provides about non-interruptability
<pippijn>
yes, but until the line is read, the rest of the program is waiting
<thelema>
or you can somehow block the network after the line is read in
<pippijn>
it would be easy if it actually modified data
avsm has joined #ocaml
<pippijn>
but I didn't code it as modify
<pippijn>
my data is immutable
<pippijn>
so only 1 thread can ever modify data
<thelema>
ok, so you need to tangle yourself in the folding that's happening on the network side?
<gustav__>
The blogeditor is annoying. Things jumping around. But it works.
eikke has joined #ocaml
<gustav__>
Dropbox as a database is nice.
<gustav__>
Make sure you save that data encrypted.
<gustav__>
:)
elixey has quit [Ping timeout: 276 seconds]
<gustav__>
But I really wonder if cryptology as is understood as the most secure today, i.e. RSA public key, really is that secure... it seems to rely on a paradox in mathemathics, or at least an unsolved problem, so, when that problem is solved, all data protected today, will be easy access. :) Not very secure. And/but a very big incentive to crack that math problem.
elixey has joined #ocaml
<K_F>
that problem is more interesting to discuss in the context of quantum computing
<gustav__>
I guess the economics mathematics professors came up with that one.
<Pantoufle>
NSA and corporations watch every bit of research done in this field
tane has quit [Quit: Verlassend]
<Pantoufle>
And IIRC now the trend is elliptic curves
<K_F>
yup
<gustav__>
They should.
<gustav__>
Or... what are they hiding? ;)
<K_F>
Got RFC6637 earlier this year (ECC in OpenPGP), so already implemented in GnuPG 2.1 and SKS 1.1.4
<gustav__>
If you have nothing to hide you have nothing to fear. ;)
<K_F>
seems GnuPG 2.1 won't support my 15,360 bit RSA key, so "had to" create a ECDSA/ECHD keyset as well
elixey has quit [Read error: Connection reset by peer]
<gustav__>
Are 2048 bit keys crackable?
<K_F>
although WK doesn't seem to consider that a regression
lolcathost has quit [Ping timeout: 252 seconds]
<gustav__>
I almost don't know what I'm talking about. But. Can I revert that cipher.
<K_F>
gustav__: quite possibly
<gustav__>
...
<gustav__>
My processor has AES instruction. I don't get that. Isn't AES outdated?
<gustav__>
I wonder if OTP is safe, because of social influence. A person, a human body, emits a lot of information.
<gustav__>
Take a picture of a body and you have 4000x4000 pixels of information or something like that.
<K_F>
"The German mistake" section.. reducing the message by 500 chars or so ...
<gustav__>
Couple that with passwords...
<K_F>
BAD IDEA..
lolcathost has quit [Ping timeout: 252 seconds]
<gustav__>
Yes, OTP can be broken if you access a machine who generated the passwords and there's a swap and that swap space hasn't been overwritten or similar...
<K_F>
gustav__: for the purposes of this discussion, then it isn't OTP
<gustav__>
So there needs to be some new theory not relying on a race of solving a math problem. Like the list of all primes.
<gustav__>
K_F: What do you mean?
<gustav__>
Oh... well. Sure it is. You use 1 of 4 password. I use the rest of 3 of 4.
lolcathost has joined #ocaml
<gustav__>
Because those are still in that swap space on that server that generated them for you.
elixey has joined #ocaml
<K_F>
I fail to see where "passwords" come into this
ftrvxmtrx has quit [Ping timeout: 252 seconds]
<gustav__>
I think coding everything you think or say is the only way to be safe.
<gustav__>
Rolling language evolution, so to speak.
<gustav__>
And these things are really, hard to do when you don't know the application.
<gustav__>
It's not like we're attacking tanks, here.
<gustav__>
But a Forever Crypt would be nice.
<gustav__>
Better to write things on a paper and lock it in a box, I think.
<gustav__>
Computers can't read that. :)
<gustav__>
US drone, might, sure... in the future.
<gustav__>
x)
<K_F>
well, I'm heading to bed anyways..
<K_F>
capitulating to the influenza
<gustav__>
Alright. Sleep well.
<gustav__>
Ah.
lolcathost has quit [Ping timeout: 260 seconds]
<gustav__>
What's the difference between OTP (one time pad) and OTP (one time password?) None, I say. Uh...
<gustav__>
One is harder to read, for a human.
<gustav__>
But I keep excluding algorithms here.
<thelema>
one time pad is used for encryption
<thelema>
one time password is just an authenticator
<thelema>
totally different uses.
<gustav__>
Sure.
<thelema>
one time pad must be as long as the message you want to send
<thelema>
one time password must be long enough to evade guessing
<gustav__>
Pad sounds like Scytale. :)
<gustav__>
They're not that similar.
<gustav__>
If they stop making quantum computers to solve RSA, it won't be solved. So that might be something to think about.
<gustav__>
Like not blowing up the planet with a nuclear bomb.
<gustav__>
Two bad ideas.
<gustav__>
You don't HAVE to do everything.
<gustav__>
Someone has to construct a computer to decipher all RSA encoded transmissions, too.
<gustav__>
Just Don't Do It<tm>.
<gustav__>
Damn, now I feel useless. Here I am, thinking about pigeons.
<gustav__>
What good has ever thinking about pigeons done humanity? :(
<thelema>
back to OCaml
<gustav__>
Yep.
lolcathost has joined #ocaml
avsm has quit [Quit: Leaving.]
<gustav__>
I have other things to do too, though.
lolcathost has quit [Ping timeout: 260 seconds]
lolcathost has joined #ocaml
Neros has quit [Read error: Connection reset by peer]