2014-07-29 00:35
ELLIOTTCABLE changed the topic of #elliottcable to: a
_better_ cult ˙ ͜ʟ˙ embrace, extend, extinguish.
00:02
<
incomprehensibly >
hi ELLIOTTCABLE i like your pokemon a lot
00:05
yrashk_ has joined #elliottcable
00:05
manveru_ has joined #elliottcable
00:09
ohhmaar_ has joined #elliottcable
00:13
russfrank has quit [*.net *.split]
00:13
yrashk has quit [*.net *.split]
00:13
audy- has quit [*.net *.split]
00:13
manveru has quit [*.net *.split]
00:13
ohhmaar has quit [*.net *.split]
00:13
ohhmaar_ is now known as ohhmaar
00:14
russfrank has joined #elliottcable
00:16
manveru_ is now known as manveru
00:54
<
alexgordon >
incomprehensibly: TYPE THEORY
00:54
* alexgordon
has rediscovered his love of abstract algebra
01:05
<
incomprehensibly >
alexgordon: <3
01:05
<
incomprehensibly >
alexgordon: i am in an analysis class and liking it a lot
01:05
<
incomprehensibly >
alexgordon: proving that 0 < 1
01:05
sharkbot has quit [Remote host closed the connection]
01:05
<
incomprehensibly >
haha
01:05
<
alexgordon >
incomprehensibly: pfft analysis is for physicists
01:05
sharkbot has joined #elliottcable
01:05
<
alexgordon >
_real_ mathematicians work from first principles xD
01:08
<
incomprehensibly >
huh?
01:14
<
alexgordon >
incomprehensibly: it's a joke :P analysis is less pure than algebra
01:15
<
incomprehensibly >
right
01:15
<
incomprehensibly >
i'm having trouble seeing the differences sometimes
01:15
<
incomprehensibly >
since like, the first thing we did was talk about fields and rings and prove things from the field axioms
01:17
<
alexgordon >
incomprehensibly: well fields are definitely important to analysis :P
01:17
<
incomprehensibly >
like, analysis is about details and algebra is about generalizing
01:17
<
incomprehensibly >
is that a correct description
01:18
<
incomprehensibly >
i've always heard "groups, rings, fields" as the domain of basic abstract algebra :P
01:18
<
alexgordon >
incomprehensibly: the one I usually hear is that analysis is about change and algebra is about structure
01:19
<
incomprehensibly >
ok
01:19
<
alexgordon >
limits are fundamental to analysis, I guess you could call that details
01:19
<
alexgordon >
really the difference is though that analysis deals with structures too complicated to understand
01:19
<
alexgordon >
i.e. the real numbers
01:20
<
alexgordon >
ever read the definition of the real numbers? with dedekind cuts and all that
01:20
<
incomprehensibly >
yeah
01:20
<
alexgordon >
in analysis you say "ok, now that we know that, we'll NEVER speak of it again"
01:20
<
incomprehensibly >
like the first thing my book did was construct naturals, construct rationals, and then construct reals from dedekind cuts
01:21
<
alexgordon >
in algebra you say "ok, now that we know that, let's generalize it to the point where we don't care about such nonsense"
01:32
<
incomprehensibly >
mhm
01:32
<
incomprehensibly >
the reals are ridiculous
01:38
<
incomprehensibly >
python is such a great language
01:39
<
alexgordon >
incomprehensibly: just wish it had proper typing
01:39
<
incomprehensibly >
sure but it's pretty sensible though
01:40
<
incomprehensibly >
like it doesn't give me the creeping sense of panic that JS does
01:40
<
incomprehensibly >
it catches errors a lot earlier than a lot of other dynamic languages
01:44
<
incomprehensibly >
the best thing about python is the consistently of the standard library and the excellent docs
01:44
<
incomprehensibly >
consistency*
01:45
<
alexgordon >
I use python for a ton of stuff
01:45
<
alexgordon >
1. it sucks for making websites
01:46
<
alexgordon >
2. static typinggggggggg
01:46
<
alexgordon >
I need it
01:46
<
alexgordon >
1 is related to 2 :P
01:47
<
alexgordon >
I want a language with the elegance of python, the asynchronicity of node and the type system of haskell
01:49
<
alexgordon >
often with mathematics the core facts are hidden behind a mountain of prose and proofs
01:49
<
alexgordon >
when sometimes I just want to see the "header file"
02:55
<
incomprehensibly >
alexgordon: should i use c++, go, rust, or swift
02:55
<
alexgordon >
incomprehensibly: for what?
02:55
<
incomprehensibly >
generating audio
02:55
<
incomprehensibly >
potentially live, eventually
02:55
<
incomprehensibly >
but for now not live
02:55
<
alexgordon >
not go
02:55
<
alexgordon >
go sucks
02:55
<
incomprehensibly >
you know what for live i'll eventually just use like fucking max or something
02:55
<
alexgordon >
not swift, swift sucks (for now)
02:55
<
alexgordon >
so it's between rust and C++
02:55
<
alexgordon >
personally I'd go for C++ because I'm biased
02:56
<
alexgordon >
rust is probably just as good
02:56
<
incomprehensibly >
ok going with c++
02:56
<
incomprehensibly >
iostreams are very overblown but like not bad
02:56
<
alexgordon >
oh I don't use iostreams
02:56
<
alexgordon >
that solves that :P
02:56
<
alexgordon >
printf ftw
02:57
<
incomprehensibly >
haha
02:57
<
incomprehensibly >
using fwrite for audioooo
02:57
<
incomprehensibly >
and then sox to play things
02:57
<
alexgordon >
I mostly try to follow the llvm style guide
02:57
<
alexgordon >
which is written by people who wrote a fucking C++ compiler, so surely they know what they're talking about
02:57
<
incomprehensibly >
haha yeah
02:57
<
alexgordon >
if THEY say iostreams suck, then iostreams suck
02:58
<
incomprehensibly >
going to use classes to represent like, samples or streams or something
02:58
<
alexgordon >
have you ever done any core audio?
02:58
<
incomprehensibly >
no
02:58
<
alexgordon >
good for you
02:58
<
incomprehensibly >
haha aight
02:59
<
alexgordon >
core audio has the messiest API, like an angry toddler sat down and decided to implement a low latency audio subsystem
02:59
<
alexgordon >
but, it's good experience if you want to write audio code
02:59
<
incomprehensibly >
hahaha
03:00
<
incomprehensibly >
i feel like low latency things are always gross
03:00
<
incomprehensibly >
:p
03:00
<
incomprehensibly >
that's why i'm doing this all .raw files instead
03:01
<
incomprehensibly >
fuck doing things is hard
03:01
<
alexgordon >
yeah if you're not doing live stuff audio is way easier
03:02
<
incomprehensibly >
so should i still do fwrite
03:02
<
incomprehensibly >
no iostream
03:03
<
alexgordon >
if you use iostream, remember to turn off "go slowly" mode
03:03
<
alexgordon >
which is on by default
03:03
<
incomprehensibly >
oh ok
03:03
<
incomprehensibly >
urgh how am i going to structure my t/radians/whatever stuff
03:03
<
alexgordon >
std::sync_with_stdio
03:04
<
alexgordon >
incomprehensibly: radians? in my audio?
03:04
<
alexgordon >
what are you making again?
03:04
<
incomprehensibly >
sine waves
03:04
<
alexgordon >
just that? lol
03:05
<
alexgordon >
some inspiring music :P
03:05
<
incomprehensibly >
well like
03:05
<
alexgordon >
"reminiscences of a tone generator in autumn"
03:05
<
incomprehensibly >
they're a good ingredient in all kinds of music
03:05
<
incomprehensibly >
lol
03:06
<
incomprehensibly >
i just want a way to write things like "a sawtooth wave at this frequency"
03:06
<
incomprehensibly >
guh, i want to do have like easy stream connection stuff, but also the power of dropping down to some algorithms
03:06
<
incomprehensibly >
and pure data/max seems like it doesn't ahve the second and c++ doesn't have the first
03:06
<
incomprehensibly >
i want tempus ;+;
03:07
<
alexgordon >
incomprehensibly: why not haskell?
03:07
<
incomprehensibly >
i suppose haskell
03:07
<
alexgordon >
sounds like something haskell would be really great at
03:07
<
incomprehensibly >
yeah i guess
03:07
<
alexgordon >
play C
03:07
<
incomprehensibly >
i want python's generator comprehensions
03:08
<
incomprehensibly >
ok haskell is definitely a good idea for this
03:08
<
incomprehensibly >
i'll just do lazy lists, and then an IO thing for outputting that as audio
03:08
<
incomprehensibly >
lists of doubles or something
03:09
<
alexgordon >
what is haskell's concept for IO without the I?
03:09
<
incomprehensibly >
what do you mean
03:09
<
alexgordon >
like in this there's no input, right?
03:09
<
incomprehensibly >
yeah
03:10
<
alexgordon >
so you're just generating a series of "play frequency X for time T" instructions
03:10
<
incomprehensibly >
well it's lower level than that
03:10
<
alexgordon >
it would seem that IO would be too heavyweight for that
03:10
<
incomprehensibly >
right?
03:10
<
alexgordon >
incomprehensibly: lower level?
03:11
<
incomprehensibly >
as in, not freuqency x for time t, just literal pcm data
03:11
<
incomprehensibly >
time series of amplitudes
03:11
<
incomprehensibly >
but anyway haskell has nothing but IO
03:11
<
incomprehensibly >
even in this case you use IO
03:11
<
alexgordon >
but don't you want a maximally pure core?
03:11
<
alexgordon >
if I were doing it, I'd take the list of (freq, t) instructions and have a function that generates the pcm for that
03:12
<
alexgordon >
which is easy enough
03:12
<
alexgordon >
but what is the correct tool for writing the abstractions over (freq, t)
03:12
<
incomprehensibly >
well i'm not just generating
*a* sine wave
03:13
<
incomprehensibly >
so a list of (freq, t) seems to be the wrong thing to be generating
03:13
<
incomprehensibly >
also fuck purity, i just want to generate some fucking 24 bit samples :p
03:13
<
alexgordon >
LOL ok
03:14
<
alexgordon >
incomprehensibly: so you're doing different wave types?
03:14
<
incomprehensibly >
like i can definitely have pure like, midi-style score representations
03:14
<
incomprehensibly >
that i serialize down into pcm via some sort of voice
03:14
<
incomprehensibly >
like, note begin & end fed to synthesizers
03:14
<
incomprehensibly >
i can make a pure lofty framework for that
03:14
<
incomprehensibly >
alexgordon: how do you mean?
03:15
<
alexgordon >
waveforms
03:17
<
incomprehensibly >
well that's one thing i want to do i guess
03:21
prophile has joined #elliottcable
03:25
<
alexgordon >
incomprehensibly: so I had an idea, you can represent a rhythm as a list of positive and negative numbers. [1, -1, 1, -1] would be a rhythm on 1 and 3
03:25
<
incomprehensibly >
oh interesting
03:25
<
alexgordon >
you'd need a scaling factor
03:26
<
incomprehensibly >
there is a lot of cool stuff i can explore with this
03:26
<
alexgordon >
so you might have a scaling factor 1/2 so that each takes up half a beat
03:26
<
alexgordon >
or a non-power of two would give you more interesting rhythms
03:29
<
incomprehensibly >
ok haskell is going to be so great to write this with
03:29
<
alexgordon >
I knews it
03:31
<
incomprehensibly >
hmm now do i just go all out and use an frp library :p
03:33
<
alexgordon >
clave = [1, -2, 1, -2, 1, -3, 1, -1, 1, -3]
03:33
<
alexgordon >
something like that anyway, maybe I should have used the 12/8 one
03:33
<
incomprehensibly >
man i want to model rhythmic things as like, multiple discrete waves with different phases and frequencies
03:34
<
alexgordon >
abstract, man
03:34
<
incomprehensibly >
well it's like how i think about rhythm a lot of the time
03:35
<
incomprehensibly >
like, something is either on beat or off beat, and sometimes switches at certain points
03:35
<
incomprehensibly >
hm idk
03:35
<
alexgordon >
I dunno, something can be between beats
03:37
* alexgordon
zzzzzzz
03:40
<
incomprehensibly >
aw
04:08
nuck has quit [Quit: Nuck Off]
04:11
nuck has joined #elliottcable
06:21
nuck has quit [Excess Flood]
06:24
nuck has joined #elliottcable
07:52
oldskirt has joined #elliottcable
07:56
oldskirt has quit [Ping timeout: 246 seconds]
07:59
audy has joined #elliottcable
08:03
eligrey has quit [Quit: Leaving]
08:04
yrashk_ has quit [Changing host]
08:04
yrashk_ has joined #elliottcable
08:04
manveru has joined #elliottcable
08:04
manveru has quit [Changing host]
09:53
oldskirt has joined #elliottcable
09:58
oldskirt has quit [Ping timeout: 272 seconds]
11:09
Sorella has joined #elliottcable
11:09
Sorella has joined #elliottcable
11:52
prophile has quit [Quit: The Game]
11:55
oldskirt has joined #elliottcable
11:59
oldskirt has quit [Ping timeout: 272 seconds]
12:08
audy has quit [Changing host]
12:08
audy has joined #elliottcable
12:35
Cheery has joined #elliottcable
12:35
<
Cheery >
were on a wrong channel
13:01
Sgeo_ has quit [Read error: Connection reset by peer]
14:57
<
katlogic_ >
YAY SCIENCE
14:57
oldskirt has joined #elliottcable
15:02
oldskirt has quit [Ping timeout: 246 seconds]
15:35
alexgordon has joined #elliottcable
16:23
<
alexgordon >
I had been working on the assumption in furrow that "a + b" would mean the same as add(a, b)
16:23
<
alexgordon >
however it occurs to me that while that works for lists (which use append() not add()) it doesn't work for sets
16:23
<
alexgordon >
add({1, 2, 3}, 4) makes sense
16:24
<
alexgordon >
{1, 2, 3} + 4 does not
16:31
katlogic_ has quit [Ping timeout: 240 seconds]
16:32
katlogic has joined #elliottcable
16:59
oldskirt has joined #elliottcable
17:03
oldskirt has quit [Ping timeout: 272 seconds]
17:10
oldskirt has joined #elliottcable
17:46
Sorella has quit [Quit: Ex-Chat]
22:02
eligrey has joined #elliottcable
22:49
Sgeo has joined #elliottcable
23:44
eligrey_ has joined #elliottcable
23:46
oldskirt has quit [Ping timeout: 255 seconds]
23:52
eligrey has quit [*.net *.split]